[U-Boot] [PATCH v3 00/26] subject: fs: fat: extend FAT write operations

[U-Boot] [PATCH v3 00/26] subject: fs: fat: extend FAT write operations

[Akashi, Takahiro]

This patch series[1] is an attempt to address FAT write related issues
in an effort of running UEFI SCT (Self-Certification Test) to verify
UEFI support on u-boot.

SCT is a test platform as well as an extensive collection of test
cases for UEFI specification. It can run all the tests automatically
and save test results to dedicated log files.

AFAIK, what's missing in the current fat file system to safely run
SCT without errors (I don't mean test case failures) are:
* write a file located under sub-directories
* write a file with non-zero offset
* delete a file
* create a directory

What's more, this series contains a file system test; "basic" test
is directly derived from test/test-fs.sh. The others, "ext" and "mkdir,"
are solely for newly added functionality in this patch series.

Patch#1 to patch#7 are some sort of preparatory ones.
Patch#8 implements write with sub-directories path.
Patch#9 to patch#11 implement write with non-zero offset.
Patch#12 to patch#16 are related to creating a directory.
Patch#17 to patch#20 allows for deleting a file or directory.
Patch#21 fixes a minor bug in fs-test.sh.
Patch#22 updates a test result summary.
Patch#23 to patch#26 add a file system test in U-boot pytest suite.

I applied this patch series on top of v2018.09-rc along with a couple
of yet-to--be-upstreamed UEFI-related patches, and could successfully
run unmodified SCT[2] on qemu-arm(arm64).

=== future TODO list ===
1. set creation (,access and modification) time
2. debug() vs. printf()
3. open()'s parameter checks
4. precisely detect and prevent write() beyond out-of-space
5. create an unique short name from a long file name
6. fat32's fsInfo support

Without (5) or (6), fsck may issue warnings.

[1] https://git.linaro.org/people/takahiro.akashi/u-boot.git fat_write
[2] http://uefi.org/testtools

Changes in v3 (Sep 11, 2018)
* remove v2's patch#4 which tries to make iterator symbols global
* add unlink operation along with a pytest script
* use guestmount, if available, for non-root user
* remove all the filesystem images created in tests

Changes in v2 (Sep 4, 2018)
* guard the whole content of fat.h with CONFIG_FS_FAT against a compiler
  warning
* determine total_sect in struct fsdata correctly, depending on fat type
  (12/16 or 32)
* explicitly revert "fs: fat: cannot write to subdirectories"
* add test scripts with pytest, mostly the same as RFC, but
  removing "sudo" for ext4 case

AKASHI Takahiro (25):
  fs: fat: guard the content of include/fat.h
  fs: fat: extend get_fs_info() for write use
  fs: fat: handle "." and ".." of root dir correctly with
    fat_itr_resolve()
  fs: fat: assure iterator's ->dent belongs to ->clust
  Revert "fs: fat: cannot write to subdirectories"
  fs: fat: check and normalize file name
  fs: fat: write returns error code instead of -1
  fs: fat: support write with sub-directory path
  fs: fat: refactor write interface for a file offset
  fs: fat: support write with non-zero offset
  cmd: fat: add offset parameter to fatwrite
  fs: add mkdir interface
  fs: fat: remember the starting cluster number of directory
  fs: fat: support mkdir
  cmd: fat: add fatmkdir command
  efi_loader: file: support creating a directory
  fs: add unlink interface
  fs: fat: support unlink
  cmd: fat: add fatrm command
  efi_loader: implement a file delete
  fs-test: fix false positive error at Test Case 12
  fs-test: update the test result as of v2018.09
  test/py: convert fs-test.sh to pytest
  test/py: fs: add extended write operation test
  test/py: fs: add fstest/mkdir test

Akashi, Takahiro (1):
  test/py: fs: add fstest/unlink test

 cmd/fat.c                            |   34 +-
 fs/fat/fat.c                         |   65 +-
 fs/fat/fat_write.c                   | 1183 +++++++++++++++++---------
 fs/fs.c                              |   87 ++
 include/fat.h                        |    7 +
 include/fs.h                         |   22 +
 lib/efi_loader/efi_file.c            |   28 +-
 test/fs/fs-test.sh                   |   24 +-
 test/py/tests/test_fs/conftest.py    |  392 +++++++++
 test/py/tests/test_fs/fstest_defs.py |   13 +
 test/py/tests/test_fs/test_basic.py  |  287 +++++++
 test/py/tests/test_fs/test_ext.py    |  224 +++++
 test/py/tests/test_fs/test_mkdir.py  |  112 +++
 test/py/tests/test_fs/test_unlink.py |  109 +++
 14 files changed, 2136 insertions(+), 451 deletions(-)
 create mode 100644 test/py/tests/test_fs/conftest.py
 create mode 100644 test/py/tests/test_fs/fstest_defs.py
 create mode 100644 test/py/tests/test_fs/test_basic.py
 create mode 100644 test/py/tests/test_fs/test_ext.py
 create mode 100644 test/py/tests/test_fs/test_mkdir.py
 create mode 100644 test/py/tests/test_fs/test_unlink.py

-- 
2.18.0

[U-Boot] [PATCH v3 01/26] fs: fat: guard the content of include/fat.h

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

The whole content of include/fat.h is private to FAT implementation
and then should be guarded with CONFIG_FS_FAT.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 include/fat.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/include/fat.h b/include/fat.h
index 09e142368585..c02839dcb040 100644
--- a/include/fat.h
+++ b/include/fat.h
@@ -9,6 +9,8 @@
 #ifndef _FAT_H_
 #define _FAT_H_
 
+#ifdef CONFIG_FS_FAT
+
 #include <asm/byteorder.h>
 #include <fs.h>
 
@@ -202,4 +204,5 @@ int fat_opendir(const char *filename, struct fs_dir_stream **dirsp);
 int fat_readdir(struct fs_dir_stream *dirs, struct fs_dirent **dentp);
 void fat_closedir(struct fs_dir_stream *dirs);
 void fat_close(void);
+#endif /* CONFIG_FS_FAT */
 #endif /* _FAT_H_ */
-- 
2.18.0

[U-Boot] [PATCH v3 02/26] fs: fat: extend get_fs_info() for write use

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

get_fs_info() was introduced in major re-work of read operation by Rob.
We want to reuse this function in write operation by extending it with
additional members in fsdata structure.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 fs/fat/fat.c  | 7 +++++++
 include/fat.h | 2 ++
 2 files changed, 9 insertions(+)

diff --git a/fs/fat/fat.c b/fs/fat/fat.c
index 4efe8a3edaf1..0576658dde09 100644
--- a/fs/fat/fat.c
+++ b/fs/fat/fat.c
@@ -558,10 +558,17 @@ static int get_fs_info(fsdata *mydata)
 
 	if (mydata->fatsize == 32) {
 		mydata->fatlength = bs.fat32_length;
+		mydata->total_sect = bs.total_sect;
 	} else {
 		mydata->fatlength = bs.fat_length;
+		mydata->total_sect = (bs.sectors[1] << 8) + bs.sectors[0];
+		if (!mydata->total_sect)
+			mydata->total_sect = bs.total_sect;
 	}
+	if (!mydata->total_sect) /* unlikely */
+		mydata->total_sect = (u32)cur_part_info.size;
 
+	mydata->fats = bs.fats;
 	mydata->fat_sect = bs.reserved;
 
 	mydata->rootdir_sect = mydata->fat_sect + mydata->fatlength * bs.fats;
diff --git a/include/fat.h b/include/fat.h
index c02839dcb040..127e6622a9b0 100644
--- a/include/fat.h
+++ b/include/fat.h
@@ -175,6 +175,8 @@ typedef struct {
 	int	fatbufnum;	/* Used by get_fatent, init to -1 */
 	int	rootdir_size;	/* Size of root dir for non-FAT32 */
 	__u32	root_cluster;	/* First cluster of root dir for FAT32 */
+	u32	total_sect;	/* Number of sectors */
+	int	fats;		/* Number of FATs */
 } fsdata;
 
 static inline u32 clust_to_sect(fsdata *fsdata, u32 clust)
-- 
2.18.0

[U-Boot] [PATCH v3 03/26] fs: fat: handle "." and ".." of root dir correctly with fat_itr_resolve()

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

FAT's root directory does not have "." nor ".."
So care must be taken when scanning root directory with fat_itr_resolve().
Without this patch, any file path starting with "." or ".." will not be
resolved at all.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 fs/fat/fat.c | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/fs/fat/fat.c b/fs/fat/fat.c
index 0576658dde09..eaea9300fd7f 100644
--- a/fs/fat/fat.c
+++ b/fs/fat/fat.c
@@ -931,6 +931,27 @@ static int fat_itr_resolve(fat_itr *itr, const char *path, unsigned type)
 	while (next[0] && !ISDIRDELIM(next[0]))
 		next++;
 
+	if (itr->is_root) {
+		/* root dir doesn't have "." nor ".." */
+		if ((((next - path) == 1) && !strncmp(path, ".", 1)) ||
+		    (((next - path) == 2) && !strncmp(path, "..", 2))) {
+			/* point back to itself */
+			itr->clust = itr->fsdata->root_cluster;
+			itr->dent = NULL;
+			itr->remaining = 0;
+			itr->last_cluster = 0;
+
+			if (next[0] == 0) {
+				if (type & TYPE_DIR)
+					return 0;
+				else
+					return -ENOENT;
+			}
+
+			return fat_itr_resolve(itr, next, type);
+		}
+	}
+
 	while (fat_itr_next(itr)) {
 		int match = 0;
 		unsigned n = max(strlen(itr->name), (size_t)(next - path));
-- 
2.18.0

[U-Boot] [PATCH v3 04/26] fs: fat: assure iterator's ->dent belongs to ->clust

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

In my attempt to re-work write operation, it was revealed that iterator's
"clust" does not always point to a cluster to which a current directory
entry ("dent") belongs.
This patch assures that it is always true by adding "next_clust" which is
used solely for dereferencing a cluster chain.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 fs/fat/fat.c | 25 +++++++++++++++++--------
 1 file changed, 17 insertions(+), 8 deletions(-)

diff --git a/fs/fat/fat.c b/fs/fat/fat.c
index eaea9300fd7f..afb8b3f9ef1a 100644
--- a/fs/fat/fat.c
+++ b/fs/fat/fat.c
@@ -641,6 +641,7 @@ static int get_fs_info(fsdata *mydata)
 typedef struct {
 	fsdata    *fsdata;        /* filesystem parameters */
 	unsigned   clust;         /* current cluster */
+	unsigned   next_clust;    /* next cluster if remaining == 0 */
 	int        last_cluster;  /* set once we've read last cluster */
 	int        is_root;       /* is iterator at root directory */
 	int        remaining;     /* remaining dent's in current cluster */
@@ -672,6 +673,7 @@ static int fat_itr_root(fat_itr *itr, fsdata *fsdata)
 
 	itr->fsdata = fsdata;
 	itr->clust = fsdata->root_cluster;
+	itr->next_clust = fsdata->root_cluster;
 	itr->dent = NULL;
 	itr->remaining = 0;
 	itr->last_cluster = 0;
@@ -707,9 +709,11 @@ static void fat_itr_child(fat_itr *itr, fat_itr *parent)
 	itr->fsdata = parent->fsdata;
 	if (clustnum > 0) {
 		itr->clust = clustnum;
+		itr->next_clust = clustnum;
 		itr->is_root = 0;
 	} else {
 		itr->clust = parent->fsdata->root_cluster;
+		itr->next_clust = parent->fsdata->root_cluster;
 		itr->is_root = 1;
 	}
 	itr->dent = NULL;
@@ -727,7 +731,7 @@ static void *next_cluster(fat_itr *itr)
 	if (itr->last_cluster)
 		return NULL;
 
-	sect = clust_to_sect(itr->fsdata, itr->clust);
+	sect = clust_to_sect(itr->fsdata, itr->next_clust);
 
 	debug("FAT read(sect=%d), clust_size=%d, DIRENTSPERBLOCK=%zd\n",
 	      sect, itr->fsdata->clust_size, DIRENTSPERBLOCK);
@@ -748,18 +752,19 @@ static void *next_cluster(fat_itr *itr)
 		return NULL;
 	}
 
+	itr->clust = itr->next_clust;
 	if (itr->is_root && itr->fsdata->fatsize != 32) {
-		itr->clust++;
-		sect = clust_to_sect(itr->fsdata, itr->clust);
+		itr->next_clust++;
+		sect = clust_to_sect(itr->fsdata, itr->next_clust);
 		if (sect - itr->fsdata->rootdir_sect >=
 		    itr->fsdata->rootdir_size) {
-			debug("cursect: 0x%x\n", itr->clust);
+			debug("nextclust: 0x%x\n", itr->next_clust);
 			itr->last_cluster = 1;
 		}
 	} else {
-		itr->clust = get_fatent(itr->fsdata, itr->clust);
-		if (CHECK_CLUST(itr->clust, itr->fsdata->fatsize)) {
-			debug("cursect: 0x%x\n", itr->clust);
+		itr->next_clust = get_fatent(itr->fsdata, itr->next_clust);
+		if (CHECK_CLUST(itr->next_clust, itr->fsdata->fatsize)) {
+			debug("nextclust: 0x%x\n", itr->next_clust);
 			itr->last_cluster = 1;
 		}
 	}
@@ -775,8 +780,11 @@ static dir_entry *next_dent(fat_itr *itr)
 			itr->fsdata->clust_size;
 
 		/* have we reached the last cluster? */
-		if (!dent)
+		if (!dent) {
+			/* a sign for no more entries left */
+			itr->dent = NULL;
 			return NULL;
+		}
 
 		itr->remaining = nbytes / sizeof(dir_entry) - 1;
 		itr->dent = dent;
@@ -937,6 +945,7 @@ static int fat_itr_resolve(fat_itr *itr, const char *path, unsigned type)
 		    (((next - path) == 2) && !strncmp(path, "..", 2))) {
 			/* point back to itself */
 			itr->clust = itr->fsdata->root_cluster;
+			itr->next_clust = itr->fsdata->root_cluster;
 			itr->dent = NULL;
 			itr->remaining = 0;
 			itr->last_cluster = 0;
-- 
2.18.0

[U-Boot] [PATCH v3 05/26] Revert "fs: fat: cannot write to subdirectories"

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

This reverts commit 0dc1bfb7302d220a48364263d5632d6d572b069b.
The succeeding patch series will supersede it.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 fs/fat/fat_write.c | 16 +---------------
 1 file changed, 1 insertion(+), 15 deletions(-)

diff --git a/fs/fat/fat_write.c b/fs/fat/fat_write.c
index 27e0ff66966c..3b77557b3ede 100644
--- a/fs/fat/fat_write.c
+++ b/fs/fat/fat_write.c
@@ -909,11 +909,9 @@ static int do_fat_write(const char *filename, void *buffer, loff_t size,
 	volume_info volinfo;
 	fsdata datablock;
 	fsdata *mydata = &datablock;
-	int cursect, i;
+	int cursect;
 	int ret = -1, name_len;
 	char l_filename[VFAT_MAXLEN_BYTES];
-	char bad[2] = " ";
-	const char illegal[] = "<>:\"/\\|?*";
 
 	*actwrite = size;
 	dir_curclust = 0;
@@ -973,18 +971,6 @@ static int do_fat_write(const char *filename, void *buffer, loff_t size,
 	}
 	dentptr = (dir_entry *) do_fat_read_at_block;
 
-	/* Strip leading (back-)slashes */
-	while ISDIRDELIM(*filename)
-		++filename;
-	/* Check that the filename is valid */
-	for (i = 0; i < strlen(illegal); ++i) {
-		*bad = illegal[i];
-		if (strstr(filename, bad)) {
-			printf("FAT: illegal filename (%s)\n", filename);
-			return -1;
-		}
-	}
-
 	name_len = strlen(filename);
 	if (name_len >= VFAT_MAXLEN_BYTES)
 		name_len = VFAT_MAXLEN_BYTES - 1;
-- 
2.18.0

[U-Boot] [PATCH v3 06/26] fs: fat: check and normalize file name

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

FAT file system's long file name support is a bit complicated and has some
restrictions on its naming. We should be careful about it especially for
write as it may easily end up with wrong file system.

normalize_longname() check for the rules and normalize a file name
if necessary. Please note, however, that this function is yet to be
extended to fully comply with the standard.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 fs/fat/fat_write.c | 52 +++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 44 insertions(+), 8 deletions(-)

diff --git a/fs/fat/fat_write.c b/fs/fat/fat_write.c
index 3b77557b3ede..6c715a70f447 100644
--- a/fs/fat/fat_write.c
+++ b/fs/fat/fat_write.c
@@ -899,6 +899,44 @@ static dir_entry *find_directory_entry(fsdata *mydata, int startsect,
 	return NULL;
 }
 
+static int normalize_longname(char *l_filename, const char *filename)
+{
+	const char *p, legal[] = "!#$%&\'()-.@^`_{}~";
+	char c;
+	int name_len;
+
+	/* Check that the filename is valid */
+	for (p = filename; p < filename + strlen(filename); p++) {
+		c = *p;
+
+		if (('0' <= c) && (c <= '9'))
+			continue;
+		if (('A' <= c) && (c <= 'Z'))
+			continue;
+		if (('a' <= c) && (c <= 'z'))
+			continue;
+		if (strchr(legal, c))
+			continue;
+		/* extended code */
+		if ((0x80 <= c) && (c <= 0xff))
+			continue;
+
+		return -1;
+	}
+
+	/* Normalize it */
+	name_len = strlen(filename);
+	if (name_len >= VFAT_MAXLEN_BYTES)
+		/* should return an error? */
+		name_len = VFAT_MAXLEN_BYTES - 1;
+
+	memcpy(l_filename, filename, name_len);
+	l_filename[name_len] = 0; /* terminate the string */
+	downcase(l_filename, INT_MAX);
+
+	return 0;
+}
+
 static int do_fat_write(const char *filename, void *buffer, loff_t size,
 			loff_t *actwrite)
 {
@@ -910,7 +948,7 @@ static int do_fat_write(const char *filename, void *buffer, loff_t size,
 	fsdata datablock;
 	fsdata *mydata = &datablock;
 	int cursect;
-	int ret = -1, name_len;
+	int ret = -1;
 	char l_filename[VFAT_MAXLEN_BYTES];
 
 	*actwrite = size;
@@ -971,13 +1009,11 @@ static int do_fat_write(const char *filename, void *buffer, loff_t size,
 	}
 	dentptr = (dir_entry *) do_fat_read_at_block;
 
-	name_len = strlen(filename);
-	if (name_len >= VFAT_MAXLEN_BYTES)
-		name_len = VFAT_MAXLEN_BYTES - 1;
-
-	memcpy(l_filename, filename, name_len);
-	l_filename[name_len] = 0; /* terminate the string */
-	downcase(l_filename, INT_MAX);
+	if (normalize_longname(l_filename, filename)) {
+		printf("FAT: illegal filename (%s)\n", filename);
+		ret = -EINVAL;
+		goto exit;
+	}
 
 	startsect = mydata->rootdir_sect;
 	retdent = find_directory_entry(mydata, startsect,
-- 
2.18.0

[U-Boot] [PATCH v3 07/26] fs: fat: write returns error code instead of -1

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

It would be good that FAT write function return error code instead of
just returning -1 as fat_read_file() does.
This patch attempts to address this issue although it is 'best effort
(or estimate)' for now.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 fs/fat/fat_write.c | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/fs/fat/fat_write.c b/fs/fat/fat_write.c
index 6c715a70f447..1e4f5af9106d 100644
--- a/fs/fat/fat_write.c
+++ b/fs/fat/fat_write.c
@@ -956,7 +956,7 @@ static int do_fat_write(const char *filename, void *buffer, loff_t size,
 
 	if (read_bootsectandvi(&bs, &volinfo, &mydata->fatsize)) {
 		debug("error: reading boot sector\n");
-		return -1;
+		return -EIO;
 	}
 
 	total_sector = bs.total_sect;
@@ -997,7 +997,7 @@ static int do_fat_write(const char *filename, void *buffer, loff_t size,
 	mydata->fatbuf = memalign(ARCH_DMA_MINALIGN, FATBUFSIZE);
 	if (mydata->fatbuf == NULL) {
 		debug("Error: allocating memory\n");
-		return -1;
+		return -ENOMEM;
 	}
 
 	if (disk_read(cursect,
@@ -1005,6 +1005,7 @@ static int do_fat_write(const char *filename, void *buffer, loff_t size,
 		(mydata->clust_size) :
 		PREFETCH_BLOCKS, do_fat_read_at_block) < 0) {
 		debug("Error: reading rootdir block\n");
+		ret = -EIO;
 		goto exit;
 	}
 	dentptr = (dir_entry *) do_fat_read_at_block;
@@ -1029,6 +1030,7 @@ static int do_fat_write(const char *filename, void *buffer, loff_t size,
 							size);
 				if (ret) {
 					printf("Error: %llu overflow\n", size);
+					ret = -ENOSPC;
 					goto exit;
 				}
 			}
@@ -1036,6 +1038,7 @@ static int do_fat_write(const char *filename, void *buffer, loff_t size,
 			ret = clear_fatent(mydata, start_cluster);
 			if (ret) {
 				printf("Error: clearing FAT entries\n");
+				ret = -EIO;
 				goto exit;
 			}
 
@@ -1045,12 +1048,14 @@ static int do_fat_write(const char *filename, void *buffer, loff_t size,
 			ret = start_cluster = find_empty_cluster(mydata);
 			if (ret < 0) {
 				printf("Error: finding empty cluster\n");
+				ret = -ENOSPC;
 				goto exit;
 			}
 
 			ret = check_overflow(mydata, start_cluster, size);
 			if (ret) {
 				printf("Error: %llu overflow\n", size);
+				ret = -ENOSPC;
 				goto exit;
 			}
 
@@ -1065,12 +1070,14 @@ static int do_fat_write(const char *filename, void *buffer, loff_t size,
 			ret = start_cluster = find_empty_cluster(mydata);
 			if (ret < 0) {
 				printf("Error: finding empty cluster\n");
+				ret = -ENOSPC;
 				goto exit;
 			}
 
 			ret = check_overflow(mydata, start_cluster, size);
 			if (ret) {
 				printf("Error: %llu overflow\n", size);
+				ret = -ENOSPC;
 				goto exit;
 			}
 		} else {
@@ -1087,6 +1094,7 @@ static int do_fat_write(const char *filename, void *buffer, loff_t size,
 	ret = set_contents(mydata, retdent, buffer, size, actwrite);
 	if (ret < 0) {
 		printf("Error: writing contents\n");
+		ret = -EIO;
 		goto exit;
 	}
 	debug("attempt to write 0x%llx bytes\n", *actwrite);
@@ -1095,14 +1103,17 @@ static int do_fat_write(const char *filename, void *buffer, loff_t size,
 	ret = flush_dirty_fat_buffer(mydata);
 	if (ret) {
 		printf("Error: flush fat buffer\n");
+		ret = -EIO;
 		goto exit;
 	}
 
 	/* Write directory table to device */
 	ret = set_cluster(mydata, dir_curclust, get_dentfromdir_block,
 			mydata->clust_size * mydata->sect_size);
-	if (ret)
+	if (ret) {
 		printf("Error: writing directory entry\n");
+		ret = -EIO;
+	}
 
 exit:
 	free(mydata->fatbuf);
@@ -1114,7 +1125,7 @@ int file_fat_write(const char *filename, void *buffer, loff_t offset,
 {
 	if (offset != 0) {
 		printf("Error: non zero offset is currently not supported.\n");
-		return -1;
+		return -EINVAL;
 	}
 
 	printf("writing %s\n", filename);
-- 
2.18.0

[U-Boot] [PATCH v3 08/26] fs: fat: support write with sub-directory path

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

In this patch, write implementation is overhauled and rewritten by
making full use of directory iterator. The obvious bonus is that we are
now able to write to a file with a directory path, like /A/B/C/FILE.

Please note that, as there is no notion of "current directory" on u-boot,
a file name specified must contain an absolute directory path. Otherwise,
"/" (root directory) is assumed.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 fs/fat/fat.c       |   9 -
 fs/fat/fat_write.c | 469 +++++++++++++++------------------------------
 2 files changed, 156 insertions(+), 322 deletions(-)

diff --git a/fs/fat/fat.c b/fs/fat/fat.c
index afb8b3f9ef1a..5aa28656c7d5 100644
--- a/fs/fat/fat.c
+++ b/fs/fat/fat.c
@@ -464,15 +464,6 @@ static __u8 mkcksum(const char name[8], const char ext[3])
 	return ret;
 }
 
-/*
- * TODO these should go away once fat_write is reworked to use the
- * directory iterator
- */
-__u8 get_dentfromdir_block[MAX_CLUSTSIZE]
-	__aligned(ARCH_DMA_MINALIGN);
-__u8 do_fat_read_at_block[MAX_CLUSTSIZE]
-	__aligned(ARCH_DMA_MINALIGN);
-
 /*
  * Read boot sector and volume info from a FAT filesystem
  */
diff --git a/fs/fat/fat_write.c b/fs/fat/fat_write.c
index 1e4f5af9106d..37ef0564eb5e 100644
--- a/fs/fat/fat_write.c
+++ b/fs/fat/fat_write.c
@@ -99,7 +99,6 @@ static void set_name(dir_entry *dirent, const char *filename)
 	debug("ext : %s\n", dirent->ext);
 }
 
-static __u8 num_of_fats;
 /*
  * Write fat buffer into block device
  */
@@ -128,7 +127,7 @@ static int flush_dirty_fat_buffer(fsdata *mydata)
 		return -1;
 	}
 
-	if (num_of_fats == 2) {
+	if (mydata->fats == 2) {
 		/* Update corresponding second FAT blocks */
 		startblock += mydata->fatlength;
 		if (disk_write(startblock, getsize, bufptr) < 0) {
@@ -210,15 +209,14 @@ name11_12:
 	return 1;
 }
 
-static int is_next_clust(fsdata *mydata, dir_entry *dentptr);
-static void flush_dir_table(fsdata *mydata, dir_entry **dentptr);
+static int flush_dir_table(fat_itr *itr);
 
 /*
  * Fill dir_slot entries with appropriate name, id, and attr
- * The real directory entry is returned by 'dentptr'
+ * 'itr' will point to a next entry
  */
-static void
-fill_dir_slot(fsdata *mydata, dir_entry **dentptr, const char *l_name)
+static int
+fill_dir_slot(fat_itr *itr, const char *l_name)
 {
 	__u8 temp_dir_slot_buffer[MAX_LFN_SLOT * sizeof(dir_slot)];
 	dir_slot *slotptr = (dir_slot *)temp_dir_slot_buffer;
@@ -226,7 +224,7 @@ fill_dir_slot(fsdata *mydata, dir_entry **dentptr, const char *l_name)
 	int idx = 0, ret;
 
 	/* Get short file name checksum value */
-	checksum = mkcksum((*dentptr)->name, (*dentptr)->ext);
+	checksum = mkcksum(itr->dent->name, itr->dent->ext);
 
 	do {
 		memset(slotptr, 0x00, sizeof(dir_slot));
@@ -241,120 +239,21 @@ fill_dir_slot(fsdata *mydata, dir_entry **dentptr, const char *l_name)
 	slotptr->id |= LAST_LONG_ENTRY_MASK;
 
 	while (counter >= 1) {
-		if (is_next_clust(mydata, *dentptr)) {
-			/* A new cluster is allocated for directory table */
-			flush_dir_table(mydata, dentptr);
-		}
-		memcpy(*dentptr, slotptr, sizeof(dir_slot));
-		(*dentptr)++;
+		memcpy(itr->dent, slotptr, sizeof(dir_slot));
 		slotptr--;
 		counter--;
-	}
-
-	if (is_next_clust(mydata, *dentptr)) {
-		/* A new cluster is allocated for directory table */
-		flush_dir_table(mydata, dentptr);
-	}
-}
-
-static __u32 dir_curclust;
-
-/*
- * Extract the full long filename starting at 'retdent' (which is really
- * a slot) into 'l_name'. If successful also copy the real directory entry
- * into 'retdent'
- * If additional adjacent cluster for directory entries is read into memory,
- * then 'get_contents_vfatname_block' is copied into 'get_dentfromdir_block' and
- * the location of the real directory entry is returned by 'retdent'
- * Return 0 on success, -1 otherwise.
- */
-static int
-get_long_file_name(fsdata *mydata, int curclust, __u8 *cluster,
-	      dir_entry **retdent, char *l_name)
-{
-	dir_entry *realdent;
-	dir_slot *slotptr = (dir_slot *)(*retdent);
-	dir_slot *slotptr2 = NULL;
-	__u8 *buflimit = cluster + mydata->sect_size * ((curclust == 0) ?
-							PREFETCH_BLOCKS :
-							mydata->clust_size);
-	__u8 counter = (slotptr->id & ~LAST_LONG_ENTRY_MASK) & 0xff;
-	int idx = 0, cur_position = 0;
-
-	if (counter > VFAT_MAXSEQ) {
-		debug("Error: VFAT name is too long\n");
-		return -1;
-	}
-
-	while ((__u8 *)slotptr < buflimit) {
-		if (counter == 0)
-			break;
-		if (((slotptr->id & ~LAST_LONG_ENTRY_MASK) & 0xff) != counter)
-			return -1;
-		slotptr++;
-		counter--;
-	}
-
-	if ((__u8 *)slotptr >= buflimit) {
-		if (curclust == 0)
-			return -1;
-		curclust = get_fatent(mydata, dir_curclust);
-		if (CHECK_CLUST(curclust, mydata->fatsize)) {
-			debug("curclust: 0x%x\n", curclust);
-			printf("Invalid FAT entry\n");
-			return -1;
-		}
-
-		dir_curclust = curclust;
-
-		if (get_cluster(mydata, curclust, get_contents_vfatname_block,
-				mydata->clust_size * mydata->sect_size) != 0) {
-			debug("Error: reading directory block\n");
-			return -1;
-		}
-
-		slotptr2 = (dir_slot *)get_contents_vfatname_block;
-		while (counter > 0) {
-			if (((slotptr2->id & ~LAST_LONG_ENTRY_MASK)
-			    & 0xff) != counter)
+		if (!fat_itr_next(itr))
+			if (!itr->dent && !itr->is_root && flush_dir_table(itr))
 				return -1;
-			slotptr2++;
-			counter--;
-		}
-
-		/* Save the real directory entry */
-		realdent = (dir_entry *)slotptr2;
-		while ((__u8 *)slotptr2 > get_contents_vfatname_block) {
-			slotptr2--;
-			slot2str(slotptr2, l_name, &idx);
-		}
-	} else {
-		/* Save the real directory entry */
-		realdent = (dir_entry *)slotptr;
 	}
 
-	do {
-		slotptr--;
-		if (slot2str(slotptr, l_name, &idx))
-			break;
-	} while (!(slotptr->id & LAST_LONG_ENTRY_MASK));
-
-	l_name[idx] = '\0';
-	if (*l_name == DELETED_FLAG)
-		*l_name = '\0';
-	else if (*l_name == aRING)
-		*l_name = DELETED_FLAG;
-	downcase(l_name, INT_MAX);
-
-	/* Return the real directory entry */
-	*retdent = realdent;
-
-	if (slotptr2) {
-		memcpy(get_dentfromdir_block, get_contents_vfatname_block,
-			mydata->clust_size * mydata->sect_size);
-		cur_position = (__u8 *)realdent - get_contents_vfatname_block;
-		*retdent = (dir_entry *) &get_dentfromdir_block[cur_position];
-	}
+	if (!itr->dent && !itr->is_root)
+		/*
+		 * don't care return value here because we have already
+		 * finished completing an entry with name, only ending up
+		 * no more entry left
+		 */
+		flush_dir_table(itr);
 
 	return 0;
 }
@@ -569,20 +468,20 @@ static int find_empty_cluster(fsdata *mydata)
 }
 
 /*
- * Write directory entries in 'get_dentfromdir_block' to block device
+ * Write directory entries in itr's buffer to block device
  */
-static void flush_dir_table(fsdata *mydata, dir_entry **dentptr)
+static int flush_dir_table(fat_itr *itr)
 {
+	fsdata *mydata = itr->fsdata;
 	int dir_newclust = 0;
+	unsigned int bytesperclust = mydata->clust_size * mydata->sect_size;
 
-	if (set_cluster(mydata, dir_curclust,
-		    get_dentfromdir_block,
-		    mydata->clust_size * mydata->sect_size) != 0) {
-		printf("error: wrinting directory entry\n");
-		return;
+	if (set_cluster(mydata, itr->clust, itr->block, bytesperclust) != 0) {
+		printf("error: writing directory entry\n");
+		return -1;
 	}
 	dir_newclust = find_empty_cluster(mydata);
-	set_fatent_value(mydata, dir_curclust, dir_newclust);
+	set_fatent_value(mydata, itr->clust, dir_newclust);
 	if (mydata->fatsize == 32)
 		set_fatent_value(mydata, dir_newclust, 0xffffff8);
 	else if (mydata->fatsize == 16)
@@ -590,15 +489,19 @@ static void flush_dir_table(fsdata *mydata, dir_entry **dentptr)
 	else if (mydata->fatsize == 12)
 		set_fatent_value(mydata, dir_newclust, 0xff8);
 
-	dir_curclust = dir_newclust;
+	itr->clust = dir_newclust;
+	itr->next_clust = dir_newclust;
 
 	if (flush_dirty_fat_buffer(mydata) < 0)
-		return;
+		return -1;
+
+	memset(itr->block, 0x00, bytesperclust);
 
-	memset(get_dentfromdir_block, 0x00,
-		mydata->clust_size * mydata->sect_size);
+	itr->dent = (dir_entry *)itr->block;
+	itr->last_cluster = 1;
+	itr->remaining = bytesperclust / sizeof(dir_entry) - 1;
 
-	*dentptr = (dir_entry *) get_dentfromdir_block;
+	return 0;
 }
 
 /*
@@ -764,139 +667,83 @@ static int check_overflow(fsdata *mydata, __u32 clustnum, loff_t size)
 	return 0;
 }
 
-/*
- * Check if adding several entries exceed one cluster boundary
- */
-static int is_next_clust(fsdata *mydata, dir_entry *dentptr)
-{
-	int cur_position;
-
-	cur_position = (__u8 *)dentptr - get_dentfromdir_block;
-
-	if (cur_position >= mydata->clust_size * mydata->sect_size)
-		return 1;
-	else
-		return 0;
-}
-
-static dir_entry *empty_dentptr;
 /*
  * Find a directory entry based on filename or start cluster number
  * If the directory entry is not found,
  * the new position for writing a directory entry will be returned
  */
-static dir_entry *find_directory_entry(fsdata *mydata, int startsect,
-	char *filename, dir_entry *retdent, __u32 start)
+static dir_entry *find_directory_entry(fat_itr *itr, char *filename)
 {
-	__u32 curclust = sect_to_clust(mydata, startsect);
-
-	debug("get_dentfromdir: %s\n", filename);
+	int match = 0;
 
-	while (1) {
-		dir_entry *dentptr;
+	while (fat_itr_next(itr)) {
+		/* check both long and short name: */
+		if (!strcasecmp(filename, itr->name))
+			match = 1;
+		else if (itr->name != itr->s_name &&
+			 !strcasecmp(filename, itr->s_name))
+			match = 1;
 
-		int i;
+		if (!match)
+			continue;
 
-		if (get_cluster(mydata, curclust, get_dentfromdir_block,
-			    mydata->clust_size * mydata->sect_size) != 0) {
-			printf("Error: reading directory block\n");
+		if (itr->dent->name[0] == '\0')
 			return NULL;
-		}
-
-		dentptr = (dir_entry *)get_dentfromdir_block;
-
-		dir_curclust = curclust;
-
-		for (i = 0; i < DIRENTSPERCLUST; i++) {
-			char s_name[14], l_name[VFAT_MAXLEN_BYTES];
-
-			l_name[0] = '\0';
-			if (dentptr->name[0] == DELETED_FLAG) {
-				dentptr++;
-				if (is_next_clust(mydata, dentptr))
-					break;
-				continue;
-			}
-			if ((dentptr->attr & ATTR_VOLUME)) {
-				if ((dentptr->attr & ATTR_VFAT) &&
-				    (dentptr->name[0] & LAST_LONG_ENTRY_MASK)) {
-					get_long_file_name(mydata, curclust,
-						     get_dentfromdir_block,
-						     &dentptr, l_name);
-					debug("vfatname: |%s|\n", l_name);
-				} else {
-					/* Volume label or VFAT entry */
-					dentptr++;
-					if (is_next_clust(mydata, dentptr))
-						break;
-					continue;
-				}
-			}
-			if (dentptr->name[0] == 0) {
-				debug("Dentname == NULL - %d\n", i);
-				empty_dentptr = dentptr;
-				return NULL;
-			}
-
-			get_name(dentptr, s_name);
-
-			if (strncasecmp(filename, s_name, sizeof(s_name)) &&
-			    strncasecmp(filename, l_name, sizeof(l_name))) {
-				debug("Mismatch: |%s|%s|\n",
-					s_name, l_name);
-				dentptr++;
-				if (is_next_clust(mydata, dentptr))
-					break;
-				continue;
-			}
+		else
+			return itr->dent;
+	}
 
-			memcpy(retdent, dentptr, sizeof(dir_entry));
+	if (!itr->dent && !itr->is_root && flush_dir_table(itr))
+		/* indicate that allocating dent failed */
+		itr->dent = NULL;
 
-			debug("DentName: %s", s_name);
-			debug(", start: 0x%x", START(dentptr));
-			debug(", size:  0x%x %s\n",
-			      FAT2CPU32(dentptr->size),
-			      (dentptr->attr & ATTR_DIR) ?
-			      "(DIR)" : "");
+	return NULL;
+}
 
-			return dentptr;
+static int split_filename(char *filename, char **dirname, char **basename)
+{
+	char *p, *last_slash, *last_slash_cont;
+
+again:
+	p = filename;
+	last_slash = NULL;
+	last_slash_cont = NULL;
+	while (*p) {
+		if (ISDIRDELIM(*p)) {
+			last_slash = p;
+			last_slash_cont = p;
+			/* continuous slashes */
+			while (ISDIRDELIM(*p))
+				last_slash_cont = p++;
+			if (!*p)
+				break;
 		}
+		p++;
+	}
 
-		/*
-		 * In FAT16/12, the root dir is locate before data area, shows
-		 * in following:
-		 * -------------------------------------------------------------
-		 * | Boot | FAT1 & 2 | Root dir | Data (start from cluster #2) |
-		 * -------------------------------------------------------------
-		 *
-		 * As a result if curclust is in Root dir, it is a negative
-		 * number or 0, 1.
-		 *
-		 */
-		if (mydata->fatsize != 32 && (int)curclust <= 1) {
-			/* Current clust is in root dir, set to next clust */
-			curclust++;
-			if ((int)curclust <= 1)
-				continue;	/* continue to find */
-
-			/* Reach the end of root dir */
-			empty_dentptr = dentptr;
-			return NULL;
+	if (last_slash) {
+		if (last_slash_cont == (filename + strlen(filename) - 1)) {
+			/* remove trailing slashes */
+			*last_slash = '\0';
+			goto again;
 		}
 
-		curclust = get_fatent(mydata, dir_curclust);
-		if (IS_LAST_CLUST(curclust, mydata->fatsize)) {
-			empty_dentptr = dentptr;
-			return NULL;
-		}
-		if (CHECK_CLUST(curclust, mydata->fatsize)) {
-			debug("curclust: 0x%x\n", curclust);
-			debug("Invalid FAT entry\n");
-			return NULL;
+		if (last_slash == filename) {
+			/* avoid ""(null) directory */
+			*dirname = "/";
+		} else {
+			*last_slash = '\0';
+			*dirname = filename;
 		}
+
+		*last_slash_cont = '\0';
+		*basename = last_slash_cont + 1;
+	} else {
+		*dirname = "/"; /* root by default */
+		*basename = filename;
 	}
 
-	return NULL;
+	return 0;
 }
 
 static int normalize_longname(char *l_filename, const char *filename)
@@ -940,86 +787,58 @@ static int normalize_longname(char *l_filename, const char *filename)
 static int do_fat_write(const char *filename, void *buffer, loff_t size,
 			loff_t *actwrite)
 {
-	dir_entry *dentptr, *retdent;
-	__u32 startsect;
+	dir_entry *retdent;
 	__u32 start_cluster;
-	boot_sector bs;
-	volume_info volinfo;
-	fsdata datablock;
+	fsdata datablock = { .fatbuf = NULL, };
 	fsdata *mydata = &datablock;
-	int cursect;
+	fat_itr *itr = NULL;
 	int ret = -1;
+	char *filename_copy, *parent, *basename;
 	char l_filename[VFAT_MAXLEN_BYTES];
 
-	*actwrite = size;
-	dir_curclust = 0;
+	filename_copy = strdup(filename);
+	if (!filename_copy)
+		return -ENOMEM;
 
-	if (read_bootsectandvi(&bs, &volinfo, &mydata->fatsize)) {
-		debug("error: reading boot sector\n");
-		return -EIO;
+	split_filename(filename_copy, &parent, &basename);
+	if (!strlen(basename)) {
+		ret = -EINVAL;
+		goto exit;
 	}
 
-	total_sector = bs.total_sect;
-	if (total_sector == 0)
-		total_sector = (int)cur_part_info.size; /* cast of lbaint_t */
-
-	if (mydata->fatsize == 32)
-		mydata->fatlength = bs.fat32_length;
-	else
-		mydata->fatlength = bs.fat_length;
-
-	mydata->fat_sect = bs.reserved;
-
-	cursect = mydata->rootdir_sect
-		= mydata->fat_sect + mydata->fatlength * bs.fats;
-	num_of_fats = bs.fats;
-
-	mydata->sect_size = (bs.sector_size[1] << 8) + bs.sector_size[0];
-	mydata->clust_size = bs.cluster_size;
-
-	if (mydata->fatsize == 32) {
-		mydata->data_begin = mydata->rootdir_sect -
-					(mydata->clust_size * 2);
-	} else {
-		int rootdir_size;
-
-		rootdir_size = ((bs.dir_entries[1]  * (int)256 +
-				 bs.dir_entries[0]) *
-				 sizeof(dir_entry)) /
-				 mydata->sect_size;
-		mydata->data_begin = mydata->rootdir_sect +
-					rootdir_size -
-					(mydata->clust_size * 2);
+	filename = basename;
+	if (normalize_longname(l_filename, filename)) {
+		printf("FAT: illegal filename (%s)\n", filename);
+		ret = -EINVAL;
+		goto exit;
 	}
 
-	mydata->fatbufnum = -1;
-	mydata->fat_dirty = 0;
-	mydata->fatbuf = memalign(ARCH_DMA_MINALIGN, FATBUFSIZE);
-	if (mydata->fatbuf == NULL) {
-		debug("Error: allocating memory\n");
-		return -ENOMEM;
+	itr = malloc_cache_aligned(sizeof(fat_itr));
+	if (!itr) {
+		ret = -ENOMEM;
+		goto exit;
 	}
 
-	if (disk_read(cursect,
-		(mydata->fatsize == 32) ?
-		(mydata->clust_size) :
-		PREFETCH_BLOCKS, do_fat_read_at_block) < 0) {
-		debug("Error: reading rootdir block\n");
-		ret = -EIO;
+	ret = fat_itr_root(itr, &datablock);
+	if (ret)
 		goto exit;
-	}
-	dentptr = (dir_entry *) do_fat_read_at_block;
 
-	if (normalize_longname(l_filename, filename)) {
-		printf("FAT: illegal filename (%s)\n", filename);
-		ret = -EINVAL;
+	total_sector = datablock.total_sect;
+
+	ret = fat_itr_resolve(itr, parent, TYPE_DIR);
+	if (ret) {
+		printf("%s: doesn't exist (%d)\n", parent, ret);
 		goto exit;
 	}
 
-	startsect = mydata->rootdir_sect;
-	retdent = find_directory_entry(mydata, startsect,
-				l_filename, dentptr, 0);
+	retdent = find_directory_entry(itr, l_filename);
+
 	if (retdent) {
+		if (fat_itr_isdir(itr)) {
+			ret = -EISDIR;
+			goto exit;
+		}
+
 		/* Update file size and start_cluster in a directory entry */
 		retdent->size = cpu_to_le32(size);
 		start_cluster = START(retdent);
@@ -1062,9 +881,31 @@ static int do_fat_write(const char *filename, void *buffer, loff_t size,
 			set_start_cluster(mydata, retdent, start_cluster);
 		}
 	} else {
+		/* Create a new file */
+
+		if (itr->is_root) {
+			/* root dir cannot have "." or ".." */
+			if (!strcmp(l_filename, ".") ||
+			    !strcmp(l_filename, "..")) {
+				ret = -EINVAL;
+				goto exit;
+			}
+		}
+
+		if (!itr->dent) {
+			printf("Error: allocating new dir entry\n");
+			ret = -EIO;
+			goto exit;
+		}
+
+		memset(itr->dent, 0, sizeof(*itr->dent));
+
 		/* Set short name to set alias checksum field in dir_slot */
-		set_name(empty_dentptr, filename);
-		fill_dir_slot(mydata, &empty_dentptr, filename);
+		set_name(itr->dent, filename);
+		if (fill_dir_slot(itr, filename)) {
+			ret = -EIO;
+			goto exit;
+		}
 
 		if (size) {
 			ret = start_cluster = find_empty_cluster(mydata);
@@ -1084,11 +925,11 @@ static int do_fat_write(const char *filename, void *buffer, loff_t size,
 			start_cluster = 0;
 		}
 
-		/* Set attribute as archieve for regular file */
-		fill_dentry(mydata, empty_dentptr, filename,
-			start_cluster, size, 0x20);
+		/* Set attribute as archive for regular file */
+		fill_dentry(itr->fsdata, itr->dent, filename,
+			    start_cluster, size, 0x20);
 
-		retdent = empty_dentptr;
+		retdent = itr->dent;
 	}
 
 	ret = set_contents(mydata, retdent, buffer, size, actwrite);
@@ -1108,15 +949,17 @@ static int do_fat_write(const char *filename, void *buffer, loff_t size,
 	}
 
 	/* Write directory table to device */
-	ret = set_cluster(mydata, dir_curclust, get_dentfromdir_block,
-			mydata->clust_size * mydata->sect_size);
+	ret = set_cluster(mydata, itr->clust, itr->block,
+			  mydata->clust_size * mydata->sect_size);
 	if (ret) {
 		printf("Error: writing directory entry\n");
 		ret = -EIO;
 	}
 
 exit:
+	free(filename_copy);
 	free(mydata->fatbuf);
+	free(itr);
 	return ret;
 }
 
-- 
2.18.0

[U-Boot] [PATCH v3 09/26] fs: fat: refactor write interface for a file offset

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

The current write implementation is quite simple: remove existing clusters
and then allocating new ones and filling them with data. This, inevitably,
enforces always writing from the beginning of a file.

As the first step to lift this restriction, fat_file_write() and
set_contents() are modified to accept an additional parameter, file offset
and further re-factored so that, in the next patch, all the necessary code
will be put into set_contents().

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 fs/fat/fat_write.c | 179 ++++++++++++++++-----------------------------
 1 file changed, 65 insertions(+), 114 deletions(-)

diff --git a/fs/fat/fat_write.c b/fs/fat/fat_write.c
index 37ef0564eb5e..c22d8c7a46a1 100644
--- a/fs/fat/fat_write.c
+++ b/fs/fat/fat_write.c
@@ -528,6 +528,42 @@ static int clear_fatent(fsdata *mydata, __u32 entry)
 	return 0;
 }
 
+/*
+ * Set start cluster in directory entry
+ */
+static void set_start_cluster(const fsdata *mydata, dir_entry *dentptr,
+			      __u32 start_cluster)
+{
+	if (mydata->fatsize == 32)
+		dentptr->starthi =
+			cpu_to_le16((start_cluster & 0xffff0000) >> 16);
+	dentptr->start = cpu_to_le16(start_cluster & 0xffff);
+}
+
+/*
+ * Check whether adding a file makes the file system to
+ * exceed the size of the block device
+ * Return -1 when overflow occurs, otherwise return 0
+ */
+static int check_overflow(fsdata *mydata, __u32 clustnum, loff_t size)
+{
+	__u32 startsect, sect_num, offset;
+
+	if (clustnum > 0)
+		startsect = clust_to_sect(mydata, clustnum);
+	else
+		startsect = mydata->rootdir_sect;
+
+	sect_num = div_u64_rem(size, mydata->sect_size, &offset);
+
+	if (offset != 0)
+		sect_num++;
+
+	if (startsect + sect_num > total_sector)
+		return -1;
+	return 0;
+}
+
 /*
  * Write at most 'maxsize' bytes from 'buffer' into
  * the file associated with 'dentptr'
@@ -535,29 +571,36 @@ static int clear_fatent(fsdata *mydata, __u32 entry)
  * or return -1 on fatal errors.
  */
 static int
-set_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer,
-	      loff_t maxsize, loff_t *gotsize)
+set_contents(fsdata *mydata, dir_entry *dentptr, loff_t pos, __u8 *buffer,
+	     loff_t maxsize, loff_t *gotsize)
 {
-	loff_t filesize = FAT2CPU32(dentptr->size);
+	loff_t filesize;
 	unsigned int bytesperclust = mydata->clust_size * mydata->sect_size;
 	__u32 curclust = START(dentptr);
 	__u32 endclust = 0, newclust = 0;
 	loff_t actsize;
 
 	*gotsize = 0;
-	debug("Filesize: %llu bytes\n", filesize);
-
-	if (maxsize > 0 && filesize > maxsize)
-		filesize = maxsize;
+	filesize = maxsize;
 
 	debug("%llu bytes\n", filesize);
 
-	if (!curclust) {
-		if (filesize) {
-			debug("error: nonempty clusterless file!\n");
+	if (curclust) {
+		/*
+		 * release already-allocated clusters anyway
+		 */
+		if (clear_fatent(mydata, curclust)) {
+			printf("Error: clearing FAT entries\n");
 			return -1;
 		}
-		return 0;
+	}
+
+	curclust = find_empty_cluster(mydata);
+	set_start_cluster(mydata, dentptr, curclust);
+
+	if (check_overflow(mydata, curclust, filesize)) {
+		printf("Error: no space left: %llu\n", filesize);
+		return -1;
 	}
 
 	actsize = bytesperclust;
@@ -568,6 +611,7 @@ set_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer,
 			newclust = determine_fatent(mydata, endclust);
 
 			if ((newclust - 1) != endclust)
+				/* write to <curclust..endclust> */
 				goto getit;
 
 			if (CHECK_CLUST(newclust, mydata->fatsize)) {
@@ -614,18 +658,8 @@ getit:
 		actsize = bytesperclust;
 		curclust = endclust = newclust;
 	} while (1);
-}
 
-/*
- * Set start cluster in directory entry
- */
-static void set_start_cluster(const fsdata *mydata, dir_entry *dentptr,
-				__u32 start_cluster)
-{
-	if (mydata->fatsize == 32)
-		dentptr->starthi =
-			cpu_to_le16((start_cluster & 0xffff0000) >> 16);
-	dentptr->start = cpu_to_le16(start_cluster & 0xffff);
+	return 0;
 }
 
 /*
@@ -642,31 +676,6 @@ static void fill_dentry(fsdata *mydata, dir_entry *dentptr,
 	set_name(dentptr, filename);
 }
 
-/*
- * Check whether adding a file makes the file system to
- * exceed the size of the block device
- * Return -1 when overflow occurs, otherwise return 0
- */
-static int check_overflow(fsdata *mydata, __u32 clustnum, loff_t size)
-{
-	__u32 startsect, sect_num, offset;
-
-	if (clustnum > 0) {
-		startsect = clust_to_sect(mydata, clustnum);
-	} else {
-		startsect = mydata->rootdir_sect;
-	}
-
-	sect_num = div_u64_rem(size, mydata->sect_size, &offset);
-
-	if (offset != 0)
-		sect_num++;
-
-	if (startsect + sect_num > total_sector)
-		return -1;
-	return 0;
-}
-
 /*
  * Find a directory entry based on filename or start cluster number
  * If the directory entry is not found,
@@ -784,11 +793,10 @@ static int normalize_longname(char *l_filename, const char *filename)
 	return 0;
 }
 
-static int do_fat_write(const char *filename, void *buffer, loff_t size,
-			loff_t *actwrite)
+int file_fat_write_at(const char *filename, loff_t pos, void *buffer,
+		      loff_t size, loff_t *actwrite)
 {
 	dir_entry *retdent;
-	__u32 start_cluster;
 	fsdata datablock = { .fatbuf = NULL, };
 	fsdata *mydata = &datablock;
 	fat_itr *itr = NULL;
@@ -796,6 +804,8 @@ static int do_fat_write(const char *filename, void *buffer, loff_t size,
 	char *filename_copy, *parent, *basename;
 	char l_filename[VFAT_MAXLEN_BYTES];
 
+	debug("writing %s\n", filename);
+
 	filename_copy = strdup(filename);
 	if (!filename_copy)
 		return -ENOMEM;
@@ -839,47 +849,8 @@ static int do_fat_write(const char *filename, void *buffer, loff_t size,
 			goto exit;
 		}
 
-		/* Update file size and start_cluster in a directory entry */
-		retdent->size = cpu_to_le32(size);
-		start_cluster = START(retdent);
-
-		if (start_cluster) {
-			if (size) {
-				ret = check_overflow(mydata, start_cluster,
-							size);
-				if (ret) {
-					printf("Error: %llu overflow\n", size);
-					ret = -ENOSPC;
-					goto exit;
-				}
-			}
-
-			ret = clear_fatent(mydata, start_cluster);
-			if (ret) {
-				printf("Error: clearing FAT entries\n");
-				ret = -EIO;
-				goto exit;
-			}
-
-			if (!size)
-				set_start_cluster(mydata, retdent, 0);
-		} else if (size) {
-			ret = start_cluster = find_empty_cluster(mydata);
-			if (ret < 0) {
-				printf("Error: finding empty cluster\n");
-				ret = -ENOSPC;
-				goto exit;
-			}
-
-			ret = check_overflow(mydata, start_cluster, size);
-			if (ret) {
-				printf("Error: %llu overflow\n", size);
-				ret = -ENOSPC;
-				goto exit;
-			}
-
-			set_start_cluster(mydata, retdent, start_cluster);
-		}
+		/* Update file size in a directory entry */
+		retdent->size = cpu_to_le32(pos + size);
 	} else {
 		/* Create a new file */
 
@@ -907,32 +878,13 @@ static int do_fat_write(const char *filename, void *buffer, loff_t size,
 			goto exit;
 		}
 
-		if (size) {
-			ret = start_cluster = find_empty_cluster(mydata);
-			if (ret < 0) {
-				printf("Error: finding empty cluster\n");
-				ret = -ENOSPC;
-				goto exit;
-			}
-
-			ret = check_overflow(mydata, start_cluster, size);
-			if (ret) {
-				printf("Error: %llu overflow\n", size);
-				ret = -ENOSPC;
-				goto exit;
-			}
-		} else {
-			start_cluster = 0;
-		}
-
 		/* Set attribute as archive for regular file */
-		fill_dentry(itr->fsdata, itr->dent, filename,
-			    start_cluster, size, 0x20);
+		fill_dentry(itr->fsdata, itr->dent, filename, 0, size, 0x20);
 
 		retdent = itr->dent;
 	}
 
-	ret = set_contents(mydata, retdent, buffer, size, actwrite);
+	ret = set_contents(mydata, retdent, pos, buffer, size, actwrite);
 	if (ret < 0) {
 		printf("Error: writing contents\n");
 		ret = -EIO;
@@ -971,6 +923,5 @@ int file_fat_write(const char *filename, void *buffer, loff_t offset,
 		return -EINVAL;
 	}
 
-	printf("writing %s\n", filename);
-	return do_fat_write(filename, buffer, maxsize, actwrite);
+	return file_fat_write_at(filename, offset, buffer, maxsize, actwrite);
 }
-- 
2.18.0

[U-Boot] [PATCH v3 10/26] fs: fat: support write with non-zero offset

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

In this patch, all the necessary code for allowing for a file offset
at write is implemented. What plays a major roll here is get_set_cluster(),
which, in contrast to its counterpart, set_cluster(), only operates on
already-allocated clusters, overwriting with data.

So, with a file offset specified, set_contents() seeks and writes data
with set_get_cluster() until the end of a file, and, once it reaches
there, continues writing with set_cluster() for the rest.

Please note that a file will be trimmed as a result of write operation if
write ends before reaching file's end. This is an intended behavior
in order to maintain compatibility with the current interface.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 fs/fat/fat_write.c | 288 ++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 273 insertions(+), 15 deletions(-)

diff --git a/fs/fat/fat_write.c b/fs/fat/fat_write.c
index c22d8c7a46a1..651c7866debc 100644
--- a/fs/fat/fat_write.c
+++ b/fs/fat/fat_write.c
@@ -450,6 +450,121 @@ set_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer,
 	return 0;
 }
 
+static __u8 tmpbuf_cluster[MAX_CLUSTSIZE] __aligned(ARCH_DMA_MINALIGN);
+
+/*
+ * Read and modify data on existing and consecutive cluster blocks
+ */
+static int
+get_set_cluster(fsdata *mydata, __u32 clustnum, loff_t pos, __u8 *buffer,
+		loff_t size, loff_t *gotsize)
+{
+	unsigned int bytesperclust = mydata->clust_size * mydata->sect_size;
+	__u32 startsect;
+	loff_t wsize;
+	int clustcount, i, ret;
+
+	*gotsize = 0;
+	if (!size)
+		return 0;
+
+	assert(pos < bytesperclust);
+	startsect = clust_to_sect(mydata, clustnum);
+
+	debug("clustnum: %d, startsect: %d, pos: %lld\n",
+	      clustnum, startsect, pos);
+
+	/* partial write@beginning */
+	if (pos) {
+		wsize = min(bytesperclust - pos, size);
+		ret = disk_read(startsect, mydata->clust_size, tmpbuf_cluster);
+		if (ret != mydata->clust_size) {
+			debug("Error reading data (got %d)\n", ret);
+			return -1;
+		}
+
+		memcpy(tmpbuf_cluster + pos, buffer, wsize);
+		ret = disk_write(startsect, mydata->clust_size, tmpbuf_cluster);
+		if (ret != mydata->clust_size) {
+			debug("Error writing data (got %d)\n", ret);
+			return -1;
+		}
+
+		size -= wsize;
+		buffer += wsize;
+		*gotsize += wsize;
+
+		startsect += mydata->clust_size;
+
+		if (!size)
+			return 0;
+	}
+
+	/* full-cluster write */
+	if (size >= bytesperclust) {
+		clustcount = lldiv(size, bytesperclust);
+
+		if (!((unsigned long)buffer & (ARCH_DMA_MINALIGN - 1))) {
+			wsize = clustcount * bytesperclust;
+			ret = disk_write(startsect,
+					 clustcount * mydata->clust_size,
+					 buffer);
+			if (ret != clustcount * mydata->clust_size) {
+				debug("Error writing data (got %d)\n", ret);
+				return -1;
+			}
+
+			size -= wsize;
+			buffer += wsize;
+			*gotsize += wsize;
+
+			startsect += clustcount * mydata->clust_size;
+		} else {
+			for (i = 0; i < clustcount; i++) {
+				memcpy(tmpbuf_cluster, buffer, bytesperclust);
+				ret = disk_write(startsect,
+						 mydata->clust_size,
+						 tmpbuf_cluster);
+				if (ret != mydata->clust_size) {
+					debug("Error writing data (got %d)\n",
+					      ret);
+					return -1;
+				}
+
+				size -= bytesperclust;
+				buffer += bytesperclust;
+				*gotsize += bytesperclust;
+
+				startsect += mydata->clust_size;
+			}
+		}
+	}
+
+	/* partial write at end */
+	if (size) {
+		wsize = size;
+		ret = disk_read(startsect, mydata->clust_size, tmpbuf_cluster);
+		if (ret != mydata->clust_size) {
+			debug("Error reading data (got %d)\n", ret);
+			return -1;
+		}
+		memcpy(tmpbuf_cluster, buffer, wsize);
+		ret = disk_write(startsect, mydata->clust_size, tmpbuf_cluster);
+		if (ret != mydata->clust_size) {
+			debug("Error writing data (got %d)\n", ret);
+			return -1;
+		}
+
+		size -= wsize;
+		buffer += wsize;
+		*gotsize += wsize;
+	}
+
+	assert(!size);
+
+	return 0;
+}
+
 /*
  * Find the first empty cluster
  */
@@ -578,26 +693,158 @@ set_contents(fsdata *mydata, dir_entry *dentptr, loff_t pos, __u8 *buffer,
 	unsigned int bytesperclust = mydata->clust_size * mydata->sect_size;
 	__u32 curclust = START(dentptr);
 	__u32 endclust = 0, newclust = 0;
-	loff_t actsize;
+	loff_t cur_pos, offset, actsize, wsize;
 
 	*gotsize = 0;
-	filesize = maxsize;
+	filesize = pos + maxsize;
 
 	debug("%llu bytes\n", filesize);
 
-	if (curclust) {
-		/*
-		 * release already-allocated clusters anyway
-		 */
-		if (clear_fatent(mydata, curclust)) {
-			printf("Error: clearing FAT entries\n");
+	if (!filesize) {
+		if (!curclust)
+			return 0;
+		if (!CHECK_CLUST(curclust, mydata->fatsize) ||
+		    IS_LAST_CLUST(curclust, mydata->fatsize)) {
+			clear_fatent(mydata, curclust);
+			set_start_cluster(mydata, dentptr, 0);
+			return 0;
+		}
+		debug("curclust: 0x%x\n", curclust);
+		debug("Invalid FAT entry\n");
+		return -1;
+	}
+
+	if (!curclust) {
+		assert(pos == 0);
+		goto set_clusters;
+	}
+
+	/* go to cluster at pos */
+	cur_pos = bytesperclust;
+	while (1) {
+		if (pos <= cur_pos)
+			break;
+		if (IS_LAST_CLUST(curclust, mydata->fatsize))
+			break;
+
+		newclust = get_fatent(mydata, curclust);
+		if (!IS_LAST_CLUST(newclust, mydata->fatsize) &&
+		    CHECK_CLUST(newclust, mydata->fatsize)) {
+			debug("curclust: 0x%x\n", curclust);
+			debug("Invalid FAT entry\n");
 			return -1;
 		}
+
+		cur_pos += bytesperclust;
+		curclust = newclust;
+	}
+	if (IS_LAST_CLUST(curclust, mydata->fatsize)) {
+		assert(pos == cur_pos);
+		goto set_clusters;
 	}
 
-	curclust = find_empty_cluster(mydata);
-	set_start_cluster(mydata, dentptr, curclust);
+	assert(pos < cur_pos);
+	cur_pos -= bytesperclust;
 
+	/* overwrite */
+	assert(IS_LAST_CLUST(curclust, mydata->fatsize) ||
+	       !CHECK_CLUST(curclust, mydata->fatsize));
+
+	while (1) {
+		/* search for allocated consecutive clusters */
+		actsize = bytesperclust;
+		endclust = curclust;
+		while (1) {
+			if (filesize <= (cur_pos + actsize))
+				break;
+
+			newclust = get_fatent(mydata, endclust);
+
+			if (IS_LAST_CLUST(newclust, mydata->fatsize))
+				break;
+			if (CHECK_CLUST(newclust, mydata->fatsize)) {
+				debug("curclust: 0x%x\n", curclust);
+				debug("Invalid FAT entry\n");
+				return -1;
+			}
+
+			actsize += bytesperclust;
+			endclust = newclust;
+		}
+
+		/* overwrite to <curclust..endclust> */
+		if (pos < cur_pos)
+			offset = 0;
+		else
+			offset = pos - cur_pos;
+		wsize = min(cur_pos + actsize, filesize) - pos;
+		if (get_set_cluster(mydata, curclust, offset,
+				    buffer, wsize, &actsize)) {
+			printf("Error get-and-setting cluster\n");
+			return -1;
+		}
+		buffer += wsize;
+		*gotsize += wsize;
+		cur_pos += offset + wsize;
+
+		if (filesize <= cur_pos)
+			break;
+
+		/* CHECK: newclust = get_fatent(mydata, endclust); */
+
+		if (IS_LAST_CLUST(newclust, mydata->fatsize))
+			/* no more clusters */
+			break;
+
+		curclust = newclust;
+	}
+
+	if (filesize <= cur_pos) {
+		/* no more write */
+		newclust = get_fatent(mydata, endclust);
+		if (!IS_LAST_CLUST(newclust, mydata->fatsize)) {
+			/* truncate the rest */
+			clear_fatent(mydata, newclust);
+
+			/* Mark end of file in FAT */
+			if (mydata->fatsize == 12)
+				newclust = 0xfff;
+			else if (mydata->fatsize == 16)
+				newclust = 0xffff;
+			else if (mydata->fatsize == 32)
+				newclust = 0xfffffff;
+			set_fatent_value(mydata, endclust, newclust);
+		}
+
+		return 0;
+	}
+
+	curclust = endclust;
+	filesize -= cur_pos;
+	assert(!(cur_pos % bytesperclust));
+
+set_clusters:
+	/* allocate and write */
+	assert(!pos);
+
+	/* Assure that curclust is valid */
+	if (!curclust) {
+		curclust = find_empty_cluster(mydata);
+		set_start_cluster(mydata, dentptr, curclust);
+	} else {
+		newclust = get_fatent(mydata, curclust);
+
+		if (IS_LAST_CLUST(newclust, mydata->fatsize)) {
+			newclust = determine_fatent(mydata, curclust);
+			set_fatent_value(mydata, curclust, newclust);
+			curclust = newclust;
+		} else {
+			debug("error: something wrong\n");
+			return -1;
+		}
+	}
+
+	/* TODO: already partially written */
 	if (check_overflow(mydata, curclust, filesize)) {
 		printf("Error: no space left: %llu\n", filesize);
 		return -1;
@@ -849,6 +1096,16 @@ int file_fat_write_at(const char *filename, loff_t pos, void *buffer,
 			goto exit;
 		}
 
+		/* A file exists */
+		if (pos == -1)
+			/* Append to the end */
+			pos = FAT2CPU32(retdent->size);
+		if (pos > retdent->size) {
+			/* No hole allowed */
+			ret = -EINVAL;
+			goto exit;
+		}
+
 		/* Update file size in a directory entry */
 		retdent->size = cpu_to_le32(pos + size);
 	} else {
@@ -869,6 +1126,12 @@ int file_fat_write_at(const char *filename, loff_t pos, void *buffer,
 			goto exit;
 		}
 
+		if (pos) {
+			/* No hole allowed */
+			ret = -EINVAL;
+			goto exit;
+		}
+
 		memset(itr->dent, 0, sizeof(*itr->dent));
 
 		/* Set short name to set alias checksum field in dir_slot */
@@ -918,10 +1181,5 @@ exit:
 int file_fat_write(const char *filename, void *buffer, loff_t offset,
 		   loff_t maxsize, loff_t *actwrite)
 {
-	if (offset != 0) {
-		printf("Error: non zero offset is currently not supported.\n");
-		return -EINVAL;
-	}
-
 	return file_fat_write_at(filename, offset, buffer, maxsize, actwrite);
 }
-- 
2.18.0

[U-Boot] [PATCH v3 11/26] cmd: fat: add offset parameter to fatwrite

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

In this patch, fatwrite command is extended so as to accept an additional
parameter of file offset.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 cmd/fat.c | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/cmd/fat.c b/cmd/fat.c
index 03de5d11afb4..2a5f7bfc2690 100644
--- a/cmd/fat.c
+++ b/cmd/fat.c
@@ -104,6 +104,7 @@ static int do_fat_fswrite(cmd_tbl_t *cmdtp, int flag,
 	int ret;
 	unsigned long addr;
 	unsigned long count;
+	long offset;
 	struct blk_desc *dev_desc = NULL;
 	disk_partition_t info;
 	int dev = 0;
@@ -126,9 +127,11 @@ static int do_fat_fswrite(cmd_tbl_t *cmdtp, int flag,
 	}
 	addr = simple_strtoul(argv[3], NULL, 16);
 	count = (argc <= 5) ? 0 : simple_strtoul(argv[5], NULL, 16);
+	/* offset should be a hex, but "-1" is allowed */
+	offset = (argc <= 6) ? 0 : simple_strtol(argv[6], NULL, 16);
 
 	buf = map_sysmem(addr, count);
-	ret = file_fat_write(argv[4], buf, 0, count, &size);
+	ret = file_fat_write(argv[4], buf, offset, count, &size);
 	unmap_sysmem(buf);
 	if (ret < 0) {
 		printf("\n** Unable to write \"%s\" from %s %d:%d **\n",
@@ -142,9 +145,9 @@ static int do_fat_fswrite(cmd_tbl_t *cmdtp, int flag,
 }
 
 U_BOOT_CMD(
-	fatwrite,	6,	0,	do_fat_fswrite,
+	fatwrite,	7,	0,	do_fat_fswrite,
 	"write file into a dos filesystem",
-	"<interface> <dev[:part]> <addr> <filename> [<bytes>]\n"
+	"<interface> <dev[:part]> <addr> <filename> [<bytes> [<offset>]]\n"
 	"    - write file 'filename' from the address 'addr' in RAM\n"
 	"      to 'dev' on 'interface'"
 );
-- 
2.18.0

[U-Boot] [PATCH v3 12/26] fs: add mkdir interface

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

"mkdir" interface is added to file operations.
This is a preparatory change as mkdir support for FAT file system
will be added in next patch.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 fs/fs.c      | 45 +++++++++++++++++++++++++++++++++++++++++++++
 include/fs.h | 10 ++++++++++
 2 files changed, 55 insertions(+)

diff --git a/fs/fs.c b/fs/fs.c
index cb68e81cd309..62165d5c5701 100644
--- a/fs/fs.c
+++ b/fs/fs.c
@@ -105,6 +105,11 @@ static inline int fs_opendir_unsupported(const char *filename,
 	return -EACCES;
 }
 
+static inline int fs_mkdir_unsupported(const char *dirname)
+{
+	return -1;
+}
+
 struct fstype_info {
 	int fstype;
 	char *name;
@@ -142,6 +147,7 @@ struct fstype_info {
 	int (*readdir)(struct fs_dir_stream *dirs, struct fs_dirent **dentp);
 	/* see fs_closedir() */
 	void (*closedir)(struct fs_dir_stream *dirs);
+	int (*mkdir)(const char *dirname);
 };
 
 static struct fstype_info fstypes[] = {
@@ -165,6 +171,7 @@ static struct fstype_info fstypes[] = {
 		.opendir = fat_opendir,
 		.readdir = fat_readdir,
 		.closedir = fat_closedir,
+		.mkdir = fs_mkdir_unsupported,
 	},
 #endif
 #ifdef CONFIG_FS_EXT4
@@ -185,6 +192,7 @@ static struct fstype_info fstypes[] = {
 #endif
 		.uuid = ext4fs_uuid,
 		.opendir = fs_opendir_unsupported,
+		.mkdir = fs_mkdir_unsupported,
 	},
 #endif
 #ifdef CONFIG_SANDBOX
@@ -201,6 +209,7 @@ static struct fstype_info fstypes[] = {
 		.write = fs_write_sandbox,
 		.uuid = fs_uuid_unsupported,
 		.opendir = fs_opendir_unsupported,
+		.mkdir = fs_mkdir_unsupported,
 	},
 #endif
 #ifdef CONFIG_CMD_UBIFS
@@ -217,6 +226,7 @@ static struct fstype_info fstypes[] = {
 		.write = fs_write_unsupported,
 		.uuid = fs_uuid_unsupported,
 		.opendir = fs_opendir_unsupported,
+		.mkdir = fs_mkdir_unsupported,
 	},
 #endif
 #ifdef CONFIG_FS_BTRFS
@@ -233,6 +243,7 @@ static struct fstype_info fstypes[] = {
 		.write = fs_write_unsupported,
 		.uuid = btrfs_uuid,
 		.opendir = fs_opendir_unsupported,
+		.mkdir = fs_mkdir_unsupported,
 	},
 #endif
 	{
@@ -248,6 +259,7 @@ static struct fstype_info fstypes[] = {
 		.write = fs_write_unsupported,
 		.uuid = fs_uuid_unsupported,
 		.opendir = fs_opendir_unsupported,
+		.mkdir = fs_mkdir_unsupported,
 	},
 };
 
@@ -498,6 +510,20 @@ void fs_closedir(struct fs_dir_stream *dirs)
 }
 
 
+int fs_mkdir(const char *dirname)
+{
+	int ret;
+
+	struct fstype_info *info = fs_get_info(fs_type);
+
+	ret = info->mkdir(dirname);
+
+	fs_type = FS_TYPE_ANY;
+	fs_close();
+
+	return ret;
+}
+
 int do_size(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
 		int fstype)
 {
@@ -700,3 +726,22 @@ int do_fs_type(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 	return CMD_RET_SUCCESS;
 }
 
+int do_mkdir(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
+	     int fstype)
+{
+	int ret;
+
+	if (argc != 4)
+		return CMD_RET_USAGE;
+
+	if (fs_set_blk_dev(argv[1], argv[2], fstype))
+		return 1;
+
+	ret = fs_mkdir(argv[3]);
+	if (ret) {
+		printf("** Unable to create a directory \"%s\" **\n", argv[3]);
+		return 1;
+	}
+
+	return 0;
+}
diff --git a/include/fs.h b/include/fs.h
index 163da103b472..fbaee154dd0d 100644
--- a/include/fs.h
+++ b/include/fs.h
@@ -155,6 +155,14 @@ struct fs_dirent *fs_readdir(struct fs_dir_stream *dirs);
  */
 void fs_closedir(struct fs_dir_stream *dirs);
 
+/*
+ * fs_mkdir - Create a directory
+ *
+ * @filename: Name of directory to create
+ * @return 0 on success, -1 on error conditions
+ */
+int fs_mkdir(const char *filename);
+
 /*
  * Common implementation for various filesystem commands, optionally limited
  * to a specific filesystem type via the fstype parameter.
@@ -169,6 +177,8 @@ int file_exists(const char *dev_type, const char *dev_part, const char *file,
 		int fstype);
 int do_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
 		int fstype);
+int do_mkdir(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
+		int fstype);
 
 /*
  * Determine the UUID of the specified filesystem and print it. Optionally it is
-- 
2.18.0

[U-Boot] [PATCH v3 13/26] fs: fat: remember the starting cluster number of directory

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

The starting cluster number of directory is needed to initialize ".."
(parent directory) entry when creating a new directory.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 fs/fat/fat.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/fs/fat/fat.c b/fs/fat/fat.c
index 5aa28656c7d5..10741925bdd4 100644
--- a/fs/fat/fat.c
+++ b/fs/fat/fat.c
@@ -631,6 +631,7 @@ static int get_fs_info(fsdata *mydata)
 
 typedef struct {
 	fsdata    *fsdata;        /* filesystem parameters */
+	unsigned   start_clust;   /* first cluster */
 	unsigned   clust;         /* current cluster */
 	unsigned   next_clust;    /* next cluster if remaining == 0 */
 	int        last_cluster;  /* set once we've read last cluster */
@@ -663,6 +664,7 @@ static int fat_itr_root(fat_itr *itr, fsdata *fsdata)
 		return -ENXIO;
 
 	itr->fsdata = fsdata;
+	itr->start_clust = 0;
 	itr->clust = fsdata->root_cluster;
 	itr->next_clust = fsdata->root_cluster;
 	itr->dent = NULL;
@@ -698,6 +700,7 @@ static void fat_itr_child(fat_itr *itr, fat_itr *parent)
 	assert(fat_itr_isdir(parent));
 
 	itr->fsdata = parent->fsdata;
+	itr->start_clust = clustnum;
 	if (clustnum > 0) {
 		itr->clust = clustnum;
 		itr->next_clust = clustnum;
-- 
2.18.0

[U-Boot] [PATCH v3 14/26] fs: fat: support mkdir

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

In this patch, mkdir support is added to FAT file system.
A newly created directory contains only "." and ".." entries.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 fs/fat/fat_write.c | 136 +++++++++++++++++++++++++++++++++++++++++++++
 fs/fs.c            |   3 +-
 include/fat.h      |   1 +
 3 files changed, 139 insertions(+), 1 deletion(-)

diff --git a/fs/fat/fat_write.c b/fs/fat/fat_write.c
index 651c7866debc..035469f31c8d 100644
--- a/fs/fat/fat_write.c
+++ b/fs/fat/fat_write.c
@@ -1183,3 +1183,139 @@ int file_fat_write(const char *filename, void *buffer, loff_t offset,
 {
 	return file_fat_write_at(filename, offset, buffer, maxsize, actwrite);
 }
+
+int fat_mkdir(const char *new_dirname)
+{
+	dir_entry *retdent;
+	fsdata datablock = { .fatbuf = NULL, };
+	fsdata *mydata = &datablock;
+	fat_itr *itr = NULL;
+	char *dirname_copy, *parent, *dirname;
+	char l_dirname[VFAT_MAXLEN_BYTES];
+	int ret = -1;
+	loff_t actwrite;
+	unsigned int bytesperclust;
+	dir_entry *dotdent = NULL;
+
+	dirname_copy = strdup(new_dirname);
+	if (!dirname_copy)
+		goto exit;
+
+	split_filename(dirname_copy, &parent, &dirname);
+	if (!strlen(dirname)) {
+		ret = -EINVAL;
+		goto exit;
+	}
+
+	if (normalize_longname(l_dirname, dirname)) {
+		printf("FAT: illegal filename (%s)\n", dirname);
+		ret = -EINVAL;
+		goto exit;
+	}
+
+	itr = malloc_cache_aligned(sizeof(fat_itr));
+	if (!itr) {
+		ret = -ENOMEM;
+		goto exit;
+	}
+
+	ret = fat_itr_root(itr, &datablock);
+	if (ret)
+		goto exit;
+
+	total_sector = datablock.total_sect;
+
+	ret = fat_itr_resolve(itr, parent, TYPE_DIR);
+	if (ret) {
+		printf("%s: doesn't exist (%d)\n", parent, ret);
+		goto exit;
+	}
+
+	retdent = find_directory_entry(itr, l_dirname);
+
+	if (retdent) {
+		printf("%s: already exists\n", l_dirname);
+		ret = -EEXIST;
+		goto exit;
+	} else {
+		if (itr->is_root) {
+			/* root dir cannot have "." or ".." */
+			if (!strcmp(l_dirname, ".") ||
+			    !strcmp(l_dirname, "..")) {
+				ret = -EINVAL;
+				goto exit;
+			}
+		}
+
+		if (!itr->dent) {
+			printf("Error: allocating new dir entry\n");
+			ret = -EIO;
+			goto exit;
+		}
+
+		memset(itr->dent, 0, sizeof(*itr->dent));
+
+		/* Set short name to set alias checksum field in dir_slot */
+		set_name(itr->dent, dirname);
+		fill_dir_slot(itr, dirname);
+
+		/* Set attribute as archive for regular file */
+		fill_dentry(itr->fsdata, itr->dent, dirname, 0, 0,
+			    ATTR_DIR | ATTR_ARCH);
+
+		retdent = itr->dent;
+	}
+
+	/* Default entries */
+	bytesperclust = mydata->clust_size * mydata->sect_size;
+	dotdent = malloc_cache_aligned(bytesperclust);
+	if (!dotdent) {
+		ret = -ENOMEM;
+		goto exit;
+	}
+	memset(dotdent, 0, bytesperclust);
+
+	memcpy(dotdent[0].name, ".       ", 8);
+	memcpy(dotdent[0].ext, "   ", 3);
+	dotdent[0].attr = ATTR_DIR | ATTR_ARCH;
+
+	memcpy(dotdent[1].name, "..      ", 8);
+	memcpy(dotdent[1].ext, "   ", 3);
+	dotdent[1].attr = ATTR_DIR | ATTR_ARCH;
+	set_start_cluster(mydata, &dotdent[1], itr->start_clust);
+
+	ret = set_contents(mydata, retdent, 0, (__u8 *)dotdent,
+			   bytesperclust, &actwrite);
+	if (ret < 0) {
+		printf("Error: writing contents\n");
+		goto exit;
+	}
+	/* Write twice for "." */
+	set_start_cluster(mydata, &dotdent[0], START(retdent));
+	ret = set_contents(mydata, retdent, 0, (__u8 *)dotdent,
+			   bytesperclust, &actwrite);
+	if (ret < 0) {
+		printf("Error: writing contents\n");
+		goto exit;
+	}
+
+	/* Flush fat buffer */
+	ret = flush_dirty_fat_buffer(mydata);
+	if (ret) {
+		printf("Error: flush fat buffer\n");
+		goto exit;
+	}
+
+	/* Write directory table to device */
+	ret = set_cluster(mydata, itr->clust, itr->block,
+			  mydata->clust_size * mydata->sect_size);
+	if (ret)
+		printf("Error: writing directory entry\n");
+
+exit:
+	free(dirname_copy);
+	free(mydata->fatbuf);
+	free(itr);
+	free(dotdent);
+	return ret;
+}
diff --git a/fs/fs.c b/fs/fs.c
index 62165d5c5701..099540f38a10 100644
--- a/fs/fs.c
+++ b/fs/fs.c
@@ -164,14 +164,15 @@ static struct fstype_info fstypes[] = {
 		.read = fat_read_file,
 #ifdef CONFIG_FAT_WRITE
 		.write = file_fat_write,
+		.mkdir = fat_mkdir,
 #else
 		.write = fs_write_unsupported,
+		.mkdir = fs_mkdir_unsupported,
 #endif
 		.uuid = fs_uuid_unsupported,
 		.opendir = fat_opendir,
 		.readdir = fat_readdir,
 		.closedir = fat_closedir,
-		.mkdir = fs_mkdir_unsupported,
 	},
 #endif
 #ifdef CONFIG_FS_EXT4
diff --git a/include/fat.h b/include/fat.h
index 127e6622a9b0..97460a3cdff1 100644
--- a/include/fat.h
+++ b/include/fat.h
@@ -205,6 +205,7 @@ int fat_read_file(const char *filename, void *buf, loff_t offset, loff_t len,
 int fat_opendir(const char *filename, struct fs_dir_stream **dirsp);
 int fat_readdir(struct fs_dir_stream *dirs, struct fs_dirent **dentp);
 void fat_closedir(struct fs_dir_stream *dirs);
+int fat_mkdir(const char *dirname);
 void fat_close(void);
 #endif /* CONFIG_FS_FAT */
 #endif /* _FAT_H_ */
-- 
2.18.0

[U-Boot] [PATCH v3 15/26] cmd: fat: add fatmkdir command

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

In this patch, a new command, fatmkdir, is added.

Please note that, as there is no notion of "current directory" on u-boot,
a directory name specified must contains an absolute directory path as
a parent directory. Otherwise, "/" (root directory) is assumed.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 cmd/fat.c | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/cmd/fat.c b/cmd/fat.c
index 2a5f7bfc2690..b685bf70a2b3 100644
--- a/cmd/fat.c
+++ b/cmd/fat.c
@@ -151,4 +151,17 @@ U_BOOT_CMD(
 	"    - write file 'filename' from the address 'addr' in RAM\n"
 	"      to 'dev' on 'interface'"
 );
+
+static int do_fat_mkdir(cmd_tbl_t *cmdtp, int flag, int argc,
+			char * const argv[])
+{
+	return do_mkdir(cmdtp, flag, argc, argv, FS_TYPE_FAT);
+}
+
+U_BOOT_CMD(
+	fatmkdir,	4,	1,	do_fat_mkdir,
+	"create a directory",
+	"<interface> [<dev[:part]>] <directory>\n"
+	"    - create a directory in 'dev' on 'interface'"
+);
 #endif
-- 
2.18.0

[U-Boot] [PATCH v3 16/26] efi_loader: file: support creating a directory

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

In efi world, there is no obvious "mkdir" interface, instead, Open()
with EFI_FILE_MODE_CREATE in mode parameter and EFI_FILE_DIRECTORY
in attributes parameter creates a directory.

In this patch, efi_file_open() is extended so as to accept such
a combination of parameters and call u-boot's mkdir interface for
expected action.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 lib/efi_loader/efi_file.c | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/lib/efi_loader/efi_file.c b/lib/efi_loader/efi_file.c
index e6a15bcb523e..6ec98c80227e 100644
--- a/lib/efi_loader/efi_file.c
+++ b/lib/efi_loader/efi_file.c
@@ -130,7 +130,8 @@ static int sanitize_path(char *path)
  * With windoze style backlashes, ofc.
  */
 static struct efi_file_handle *file_open(struct file_system *fs,
-		struct file_handle *parent, s16 *file_name, u64 mode)
+		struct file_handle *parent, s16 *file_name, u64 mode,
+		u64 attributes)
 {
 	struct file_handle *fh;
 	char f0[MAX_UTF8_PER_UTF16] = {0};
@@ -173,7 +174,12 @@ static struct efi_file_handle *file_open(struct file_system *fs,
 		if (set_blk_dev(fh))
 			goto error;
 
-		if (!((mode & EFI_FILE_MODE_CREATE) || fs_exists(fh->path)))
+		if ((mode & EFI_FILE_MODE_CREATE) &&
+		    (attributes & EFI_FILE_DIRECTORY)) {
+			if (fs_mkdir(fh->path))
+				goto error;
+		} else if (!((mode & EFI_FILE_MODE_CREATE) ||
+			     fs_exists(fh->path)))
 			goto error;
 
 		/* figure out if file is a directory: */
@@ -199,7 +205,7 @@ static efi_status_t EFIAPI efi_file_open(struct efi_file_handle *file,
 	EFI_ENTRY("%p, %p, \"%ls\", %llx, %llu", file, new_handle, file_name,
 		  open_mode, attributes);
 
-	*new_handle = file_open(fh->fs, fh, file_name, open_mode);
+	*new_handle = file_open(fh->fs, fh, file_name, open_mode, attributes);
 	if (!*new_handle)
 		return EFI_EXIT(EFI_NOT_FOUND);
 
@@ -598,7 +604,7 @@ efi_open_volume(struct efi_simple_file_system_protocol *this,
 
 	EFI_ENTRY("%p, %p", this, root);
 
-	*root = file_open(fs, NULL, NULL, 0);
+	*root = file_open(fs, NULL, NULL, 0, 0);
 
 	return EFI_EXIT(EFI_SUCCESS);
 }
-- 
2.18.0

[U-Boot] [PATCH v3 17/26] fs: add unlink interface

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

"unlink" interface is added to file operations.
This is a preparatory change as unlink support for FAT file system
will be added in next patch.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 fs/fs.c      | 40 ++++++++++++++++++++++++++++++++++++++++
 include/fs.h | 12 ++++++++++++
 2 files changed, 52 insertions(+)

diff --git a/fs/fs.c b/fs/fs.c
index 099540f38a10..ba9a65166c70 100644
--- a/fs/fs.c
+++ b/fs/fs.c
@@ -105,6 +105,11 @@ static inline int fs_opendir_unsupported(const char *filename,
 	return -EACCES;
 }
 
+static inline int fs_unlink_unsupported(const char *filename)
+{
+	return -1;
+}
+
 static inline int fs_mkdir_unsupported(const char *dirname)
 {
 	return -1;
@@ -147,6 +152,7 @@ struct fstype_info {
 	int (*readdir)(struct fs_dir_stream *dirs, struct fs_dirent **dentp);
 	/* see fs_closedir() */
 	void (*closedir)(struct fs_dir_stream *dirs);
+	int (*unlink)(const char *filename);
 	int (*mkdir)(const char *dirname);
 };
 
@@ -173,6 +179,7 @@ static struct fstype_info fstypes[] = {
 		.opendir = fat_opendir,
 		.readdir = fat_readdir,
 		.closedir = fat_closedir,
+		.unlink = fs_unlink_unsupported,
 	},
 #endif
 #ifdef CONFIG_FS_EXT4
@@ -193,6 +200,7 @@ static struct fstype_info fstypes[] = {
 #endif
 		.uuid = ext4fs_uuid,
 		.opendir = fs_opendir_unsupported,
+		.unlink = fs_unlink_unsupported,
 		.mkdir = fs_mkdir_unsupported,
 	},
 #endif
@@ -210,6 +218,7 @@ static struct fstype_info fstypes[] = {
 		.write = fs_write_sandbox,
 		.uuid = fs_uuid_unsupported,
 		.opendir = fs_opendir_unsupported,
+		.unlink = fs_unlink_unsupported,
 		.mkdir = fs_mkdir_unsupported,
 	},
 #endif
@@ -227,6 +236,7 @@ static struct fstype_info fstypes[] = {
 		.write = fs_write_unsupported,
 		.uuid = fs_uuid_unsupported,
 		.opendir = fs_opendir_unsupported,
+		.unlink = fs_unlink_unsupported,
 		.mkdir = fs_mkdir_unsupported,
 	},
 #endif
@@ -244,6 +254,7 @@ static struct fstype_info fstypes[] = {
 		.write = fs_write_unsupported,
 		.uuid = btrfs_uuid,
 		.opendir = fs_opendir_unsupported,
+		.unlink = fs_unlink_unsupported,
 		.mkdir = fs_mkdir_unsupported,
 	},
 #endif
@@ -260,6 +271,7 @@ static struct fstype_info fstypes[] = {
 		.write = fs_write_unsupported,
 		.uuid = fs_uuid_unsupported,
 		.opendir = fs_opendir_unsupported,
+		.unlink = fs_unlink_unsupported,
 		.mkdir = fs_mkdir_unsupported,
 	},
 };
@@ -510,6 +522,19 @@ void fs_closedir(struct fs_dir_stream *dirs)
 	fs_close();
 }
 
+int fs_unlink(const char *filename)
+{
+	int ret;
+
+	struct fstype_info *info = fs_get_info(fs_type);
+
+	ret = info->unlink(filename);
+
+	fs_type = FS_TYPE_ANY;
+	fs_close();
+
+	return ret;
+}
 
 int fs_mkdir(const char *dirname)
 {
@@ -727,6 +752,21 @@ int do_fs_type(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 	return CMD_RET_SUCCESS;
 }
 
+int do_rm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
+	  int fstype)
+{
+	if (argc != 4)
+		return CMD_RET_USAGE;
+
+	if (fs_set_blk_dev(argv[1], argv[2], fstype))
+		return 1;
+
+	if (fs_unlink(argv[3]))
+		return 1;
+
+	return 0;
+}
+
 int do_mkdir(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
 	     int fstype)
 {
diff --git a/include/fs.h b/include/fs.h
index fbaee154dd0d..aa3604db8dc4 100644
--- a/include/fs.h
+++ b/include/fs.h
@@ -155,6 +155,16 @@ struct fs_dirent *fs_readdir(struct fs_dir_stream *dirs);
  */
 void fs_closedir(struct fs_dir_stream *dirs);
 
+/*
+ * fs_unlink - delete a file or directory
+ *
+ * If a given name is a directory, it will be deleted only if it's empty
+ *
+ * @filename: Name of file or directory to delete
+ * @return 0 on success, -1 on error conditions
+ */
+int fs_unlink(const char *filename);
+
 /*
  * fs_mkdir - Create a directory
  *
@@ -177,6 +187,8 @@ int file_exists(const char *dev_type, const char *dev_part, const char *file,
 		int fstype);
 int do_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
 		int fstype);
+int do_rm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
+		int fstype);
 int do_mkdir(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
 		int fstype);
 
-- 
2.18.0

[U-Boot] [PATCH v3 18/26] fs: fat: support unlink

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

In this patch, unlink support is added to FAT file system.
A directory can be deleted only if it is empty.

In this implementation, only a directory entry for a short file name
will be removed. So entries for a long file name can and should be
reclaimed with fsck.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 fs/fat/fat_write.c | 132 +++++++++++++++++++++++++++++++++++++++++++++
 fs/fs.c            |   3 +-
 include/fat.h      |   1 +
 3 files changed, 135 insertions(+), 1 deletion(-)

diff --git a/fs/fat/fat_write.c b/fs/fat/fat_write.c
index 035469f31c8d..6d3d2d1abb04 100644
--- a/fs/fat/fat_write.c
+++ b/fs/fat/fat_write.c
@@ -1184,6 +1184,138 @@ int file_fat_write(const char *filename, void *buffer, loff_t offset,
 	return file_fat_write_at(filename, offset, buffer, maxsize, actwrite);
 }
 
+static int fat_dir_entries(fat_itr *itr)
+{
+	fat_itr *dirs;
+	fsdata fsdata = { .fatbuf = NULL, }, *mydata = &fsdata;
+						/* for FATBUFSIZE */
+	int count;
+
+	dirs = malloc_cache_aligned(sizeof(fat_itr));
+	if (!dirs) {
+		debug("Error: allocating memory\n");
+		count = -ENOMEM;
+		goto exit;
+	}
+
+	/* duplicate fsdata */
+	fat_itr_child(dirs, itr);
+	fsdata = *dirs->fsdata;
+
+	/* allocate local fat buffer */
+	fsdata.fatbuf = malloc_cache_aligned(FATBUFSIZE);
+	if (!fsdata.fatbuf) {
+		debug("Error: allocating memory\n");
+		count = -ENOMEM;
+		goto exit;
+	}
+	fsdata.fatbufnum = -1;
+	dirs->fsdata = &fsdata;
+
+	for (count = 0; fat_itr_next(dirs); count++)
+		;
+
+exit:
+	free(fsdata.fatbuf);
+	free(dirs);
+	return count;
+}
+
+static int delete_dentry(fat_itr *itr)
+{
+	fsdata *mydata = itr->fsdata;
+	dir_entry *dentptr = itr->dent;
+
+	/* free cluster blocks */
+	clear_fatent(mydata, START(dentptr));
+	if (flush_dirty_fat_buffer(mydata) < 0) {
+		printf("Error: flush fat buffer\n");
+		return -EIO;
+	}
+
+	/*
+	 * update a directory entry
+	 * TODO:
+	 *  - long file name support
+	 *  - find and mark the "new" first invalid entry as name[0]=0x00
+	 */
+	memset(dentptr, 0, sizeof(*dentptr));
+	dentptr->name[0] = 0xe5;
+
+	if (set_cluster(mydata, itr->clust, itr->block,
+			mydata->clust_size * mydata->sect_size) != 0) {
+		printf("error: writing directory entry\n");
+		return -EIO;
+	}
+
+	return 0;
+}
+
+int fat_unlink(const char *filename)
+{
+	fsdata fsdata = { .fatbuf = NULL, };
+	fat_itr *itr = NULL;
+	int n_entries, ret;
+	char *filename_copy, *dirname, *basename;
+
+	filename_copy = strdup(filename);
+	split_filename(filename_copy, &dirname, &basename);
+
+	if (!strcmp(dirname, "/") && !strcmp(basename, "")) {
+		printf("Error: cannot remove root\n");
+		ret = -EINVAL;
+		goto exit;
+	}
+
+	itr = malloc_cache_aligned(sizeof(fat_itr));
+	if (!itr) {
+		printf("Error: allocating memory\n");
+		return -ENOMEM;
+	}
+
+	ret = fat_itr_root(itr, &fsdata);
+	if (ret)
+		goto exit;
+
+	total_sector = fsdata.total_sect;
+
+	ret = fat_itr_resolve(itr, dirname, TYPE_DIR);
+	if (ret) {
+		printf("%s: doesn't exist (%d)\n", dirname, ret);
+		ret = -ENOENT;
+		goto exit;
+	}
+
+	if (!find_directory_entry(itr, basename)) {
+		printf("%s: doesn't exist\n", basename);
+		ret = -ENOENT;
+		goto exit;
+	}
+
+	if (fat_itr_isdir(itr)) {
+		n_entries = fat_dir_entries(itr);
+		if (n_entries < 0) {
+			ret = n_entries;
+			goto exit;
+		}
+		if (n_entries > 2) {
+			printf("Error: directory is not empty: %d\n",
+			       n_entries);
+			ret = -EINVAL;
+			goto exit;
+		}
+	}
+
+	ret = delete_dentry(itr);
+
+exit:
+	free(fsdata.fatbuf);
+	free(itr);
+	free(filename_copy);
+
+	return ret;
+}
+
 int fat_mkdir(const char *new_dirname)
 {
 	dir_entry *retdent;
diff --git a/fs/fs.c b/fs/fs.c
index ba9a65166c70..adae98d021ee 100644
--- a/fs/fs.c
+++ b/fs/fs.c
@@ -170,16 +170,17 @@ static struct fstype_info fstypes[] = {
 		.read = fat_read_file,
 #ifdef CONFIG_FAT_WRITE
 		.write = file_fat_write,
+		.unlink = fat_unlink,
 		.mkdir = fat_mkdir,
 #else
 		.write = fs_write_unsupported,
+		.unlink = fs_unlink_unsupported,
 		.mkdir = fs_mkdir_unsupported,
 #endif
 		.uuid = fs_uuid_unsupported,
 		.opendir = fat_opendir,
 		.readdir = fat_readdir,
 		.closedir = fat_closedir,
-		.unlink = fs_unlink_unsupported,
 	},
 #endif
 #ifdef CONFIG_FS_EXT4
diff --git a/include/fat.h b/include/fat.h
index 97460a3cdff1..ca92a735b4fd 100644
--- a/include/fat.h
+++ b/include/fat.h
@@ -205,6 +205,7 @@ int fat_read_file(const char *filename, void *buf, loff_t offset, loff_t len,
 int fat_opendir(const char *filename, struct fs_dir_stream **dirsp);
 int fat_readdir(struct fs_dir_stream *dirs, struct fs_dirent **dentp);
 void fat_closedir(struct fs_dir_stream *dirs);
+int fat_unlink(const char *filename);
 int fat_mkdir(const char *dirname);
 void fat_close(void);
 #endif /* CONFIG_FS_FAT */
-- 
2.18.0

[U-Boot] [PATCH v3 19/26] cmd: fat: add fatrm command

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

In this patch, a new command, fatrm, is added so as to delete a file
or directory.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 cmd/fat.c | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/cmd/fat.c b/cmd/fat.c
index b685bf70a2b3..4b9a7eaab054 100644
--- a/cmd/fat.c
+++ b/cmd/fat.c
@@ -152,6 +152,18 @@ U_BOOT_CMD(
 	"      to 'dev' on 'interface'"
 );
 
+static int do_fat_rm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+{
+	return do_rm(cmdtp, flag, argc, argv, FS_TYPE_FAT);
+}
+
+U_BOOT_CMD(
+	fatrm,	4,	1,	do_fat_rm,
+	"delete a file",
+	"<interface> [<dev[:part]>] <filename>\n"
+	"    - delete a file from 'dev' on 'interface'"
+);
+
 static int do_fat_mkdir(cmd_tbl_t *cmdtp, int flag, int argc,
 			char * const argv[])
 {
-- 
2.18.0

[U-Boot] [PATCH v3 20/26] efi_loader: implement a file delete

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

'Delete' will be implemented here by calling fs_unlink() which relies on
underlying file system's implementation.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 lib/efi_loader/efi_file.c | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/lib/efi_loader/efi_file.c b/lib/efi_loader/efi_file.c
index 6ec98c80227e..e726bb0eb2d2 100644
--- a/lib/efi_loader/efi_file.c
+++ b/lib/efi_loader/efi_file.c
@@ -229,9 +229,21 @@ static efi_status_t EFIAPI efi_file_close(struct efi_file_handle *file)
 static efi_status_t EFIAPI efi_file_delete(struct efi_file_handle *file)
 {
 	struct file_handle *fh = to_fh(file);
+	efi_status_t ret = EFI_SUCCESS;
+
 	EFI_ENTRY("%p", file);
+
+	if (set_blk_dev(fh)) {
+		ret = EFI_DEVICE_ERROR;
+		goto error;
+	}
+
+	if (fs_unlink(fh->path))
+		ret = EFI_DEVICE_ERROR;
 	file_close(fh);
-	return EFI_EXIT(EFI_WARN_DELETE_FAILURE);
+
+error:
+	return EFI_EXIT(ret);
 }
 
 static efi_status_t file_read(struct file_handle *fh, u64 *buffer_size,
-- 
2.18.0

[U-Boot] [PATCH v3 21/26] fs-test: fix false positive error at Test Case 12

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

The error message to be matched is wrong. Fix it.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 test/fs/fs-test.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/fs/fs-test.sh b/test/fs/fs-test.sh
index 9482239562ea..e002b9105131 100755
--- a/test/fs/fs-test.sh
+++ b/test/fs/fs-test.sh
@@ -522,7 +522,7 @@ function check_results() {
 		"TC11: 1MB write to $3.w - content verified"
 
 	# Check lookup of 'dot' directory
-	grep -A4 "Test Case 12 " "$1" | grep -q 'Unable to write file'
+	grep -A4 "Test Case 12 " "$1" | grep -q 'Unable to write'
 	pass_fail "TC12: 1MB write to . - write denied"
 
 	# Check directory traversal
-- 
2.18.0

[U-Boot] [PATCH v3 22/26] fs-test: update the test result as of v2018.09

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

As far as this patch series has been applied, all the tests should
pass. So update the test result summary.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 test/fs/fs-test.sh | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/test/fs/fs-test.sh b/test/fs/fs-test.sh
index e002b9105131..86308cfe2dbd 100755
--- a/test/fs/fs-test.sh
+++ b/test/fs/fs-test.sh
@@ -7,18 +7,20 @@
 # It currently tests the fs/sb and native commands for ext4 and fat partitions
 # Expected results are as follows:
 # EXT4 tests:
-# fs-test.sb.ext4.out: Summary: PASS: 24 FAIL: 0
-# fs-test.ext4.out: Summary: PASS: 24 FAIL: 0
-# fs-test.fs.ext4.out: Summary: PASS: 24 FAIL: 0
+# fs-test.sb.ext4	Summary: PASS: 24 FAIL: 0
+# fs-test.nonfs.ext4	Summary: PASS: 24 FAIL: 0
+# fs-test.fs.ext4	Summary: PASS: 24 FAIL: 0
 # FAT16 tests:
-# fs-test.sb.fat16.out: Summary: PASS: 24 FAIL: 0
-# fs-test.fat16.out: Summary: PASS: 20 FAIL: 4
-# fs-test.fs.fat16.out: Summary: PASS: 20 FAIL: 4
+# fs-test.sb.fat16	Summary: PASS: 24 FAIL: 0
+# fs-test.nonfs.fat16	Summary: PASS: 24 FAIL: 0
+# fs-test.fs.fat16	Summary: PASS: 24 FAIL: 0
 # FAT32 tests:
-# fs-test.sb.fat32.out: Summary: PASS: 24 FAIL: 0
-# fs-test.fat32.out: Summary: PASS: 20 FAIL: 4
-# fs-test.fs.fat32.out: Summary: PASS: 20 FAIL: 4
-# Total Summary: TOTAL PASS: 200 TOTAL FAIL: 16
+# fs-test.sb.fat32	Summary: PASS: 24 FAIL: 0
+# fs-test.nonfs.fat32	Summary: PASS: 24 FAIL: 0
+# fs-test.fs.fat32	Summary: PASS: 24 FAIL: 0
+# --------------------------------------------
+# Total Summary: TOTAL PASS: 216 TOTAL FAIL: 0
+# --------------------------------------------
 
 # pre-requisite binaries list.
 PREREQ_BINS="md5sum mkfs mount umount dd fallocate mkdir"
-- 
2.18.0

[U-Boot] [PATCH v3 23/26] test/py: convert fs-test.sh to pytest

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

In this commit, the same set of test cases as in test/fs/fs-test.sh
is provided using pytest framework.
Actually, fs-test.sh provides three variants:"sb" (sb command), "nonfs"
(fatxx and etc.) and "fs" (hostfs), and this patch currently supports
only "nonfs" variant; So it is not a replacement of fs-test.sh for now.

Simple usage:
  $ py.test test/py/tests/test_fs [<other options>]

You may also specify filesystem types to be tested:
  $ py.test test/py/tests/test_fs --fs-type fat32 [<other options>]

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 test/py/tests/test_fs/conftest.py    | 218 ++++++++++++++++++++
 test/py/tests/test_fs/fstest_defs.py |  10 +
 test/py/tests/test_fs/test_basic.py  | 287 +++++++++++++++++++++++++++
 3 files changed, 515 insertions(+)
 create mode 100644 test/py/tests/test_fs/conftest.py
 create mode 100644 test/py/tests/test_fs/fstest_defs.py
 create mode 100644 test/py/tests/test_fs/test_basic.py

diff --git a/test/py/tests/test_fs/conftest.py b/test/py/tests/test_fs/conftest.py
new file mode 100644
index 000000000000..3437accc971f
--- /dev/null
+++ b/test/py/tests/test_fs/conftest.py
@@ -0,0 +1,218 @@
+# SPDX-License-Identifier:      GPL-2.0+
+# Copyright (c) 2018, Linaro Limited
+# Author: Takahiro Akashi <takahiro.akashi@linaro.org>
+
+import os
+import os.path
+import pytest
+import re
+from subprocess import call, check_call, check_output, CalledProcessError
+from fstest_defs import *
+
+supported_fs_basic = ['fat16', 'fat32', 'ext4']
+
+#
+# Filesystem test specific setup
+#
+def pytest_addoption(parser):
+    parser.addoption('--fs-type', action='append', default=None,
+        help='Targeting Filesystem Types')
+
+def pytest_configure(config):
+    global supported_fs_basic
+
+    def intersect(listA, listB):
+        return  [x for x in listA if x in listB]
+
+    supported_fs = config.getoption('fs_type')
+    if supported_fs:
+        print("*** FS TYPE modified: %s" % supported_fs)
+        supported_fs_basic =  intersect(supported_fs, supported_fs_basic)
+
+def pytest_generate_tests(metafunc):
+    if 'fs_obj_basic' in metafunc.fixturenames:
+        metafunc.parametrize('fs_obj_basic', supported_fs_basic,
+            indirect=True, scope='module')
+
+#
+# Helper functions
+#
+def fstype_to_ubname(fs_type):
+    if re.match('fat', fs_type):
+        return 'fat'
+    else:
+        return fs_type
+
+def check_ubconfig(config, fs_type):
+    if not config.buildconfig.get('config_cmd_%s' % fs_type, None):
+        pytest.skip('.config feature "CMD_%s" not enabled' % fs_type.upper())
+    if not config.buildconfig.get('config_%s_write' % fs_type, None):
+        pytest.skip('.config feature "%s_WRITE" not enabled'
+        % fs_type.upper())
+
+def mk_fs(config, fs_type, size, id):
+    fs_img = '%s.%s.img' % (id, fs_type)
+    fs_img = config.persistent_data_dir + '/' + fs_img
+
+    if fs_type == 'fat16':
+        mkfs_opt = '-F 16'
+    elif fs_type == 'fat32':
+        mkfs_opt = '-F 32'
+    else:
+        mkfs_opt = ''
+
+    if re.match('fat', fs_type):
+        fs_lnxtype = 'vfat'
+    else:
+        fs_lnxtype = fs_type
+
+    count = (size + 1048576 - 1) / 1048576
+
+    try:
+        check_call('rm -f %s' % fs_img, shell=True)
+        check_call('dd if=/dev/zero of=%s bs=1M count=%d'
+            % (fs_img, count), shell=True)
+        check_call('mkfs.%s %s %s'
+            % (fs_lnxtype, mkfs_opt, fs_img), shell=True)
+        return fs_img
+    except CalledProcessError:
+        call('rm -f %s' % fs_img, shell=True)
+        raise
+
+# from test/py/conftest.py
+def tool_is_in_path(tool):
+    for path in os.environ["PATH"].split(os.pathsep):
+        fn = os.path.join(path, tool)
+        if os.path.isfile(fn) and os.access(fn, os.X_OK):
+            return True
+    return False
+
+fuse_mounted = False
+
+def mount_fs(fs_type, device, mount_point):
+    global fuse_mounted
+
+    fuse_mounted = False
+    try:
+        if tool_is_in_path('guestmount'):
+            fuse_mounted = True
+            check_call('guestmount -a %s -m /dev/sda %s'
+                % (device, mount_point), shell=True)
+        else:
+            mount_opt = "loop,rw"
+            if re.match('fat', fs_type):
+                mount_opt += ",umask=0000"
+
+            check_call('sudo mount -o %s %s %s'
+                % (mount_opt, device, mount_point), shell=True)
+
+            # may not be effective for some file systems
+            check_call('sudo chmod a+rw %s' % mount_point, shell=True)
+    except CalledProcessError:
+        raise
+
+def umount_fs(fs_type, mount_point):
+    if fuse_mounted:
+        call('sync')
+        call('guestunmount %s' % mount_point, shell=True)
+    else:
+        call('sudo umount %s' % mount_point, shell=True)
+
+#
+# Fixture for basic fs test
+#     derived from test/fs/fs-test.sh
+#
+# NOTE: yield_fixture was deprecated since pytest-3.0
+ at pytest.yield_fixture()
+def fs_obj_basic(request, u_boot_config):
+    fs_type = request.param
+    fs_img = ''
+
+    fs_ubtype = fstype_to_ubname(fs_type)
+    check_ubconfig(u_boot_config, fs_ubtype)
+
+    mount_dir = u_boot_config.persistent_data_dir + '/mnt'
+
+    small_file = mount_dir + '/' + SMALL_FILE
+    big_file = mount_dir + '/' + BIG_FILE
+
+    try:
+
+        # 3GiB volume
+        fs_img = mk_fs(u_boot_config, fs_type, 0xc0000000, '3GB')
+
+        # Mount the image so we can populate it.
+        check_call('mkdir -p %s' % mount_dir, shell=True)
+        mount_fs(fs_type, fs_img, mount_dir)
+
+        # Create a subdirectory.
+        check_call('mkdir %s/SUBDIR' % mount_dir, shell=True)
+
+        # Create 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.
+        check_call('dd if=/dev/urandom of=%s bs=1M count=1'
+	    % big_file, shell=True)
+        check_call('dd if=/dev/urandom of=%s bs=1M count=2 seek=2047'
+            % big_file, shell=True)
+        check_call('dd if=/dev/urandom of=%s bs=1M count=1 seek=2499'
+            % big_file, shell=True)
+
+        # Create a small file in this image.
+        check_call('dd if=/dev/urandom of=%s bs=1M count=1'
+	    % small_file, shell=True)
+
+        # Delete the small file copies which possibly are written as part of a
+        # previous test.
+        # check_call('rm -f "%s.w"' % MB1, shell=True)
+        # check_call('rm -f "%s.w2"' % MB1, shell=True)
+
+        # Generate the md5sums of reads that we will test against small file
+        out = check_output(
+            'dd if=%s bs=1M skip=0 count=1 2> /dev/null | md5sum'
+	    % small_file, shell=True)
+        md5val = [ out.split()[0] ]
+
+        # Generate the md5sums of reads that we will test against big file
+        # One from beginning of file.
+        out = check_output(
+            'dd if=%s bs=1M skip=0 count=1 2> /dev/null | md5sum'
+	    % big_file, shell=True)
+        md5val.append(out.split()[0])
+
+        # One from end of file.
+        out = check_output(
+            'dd if=%s bs=1M skip=2499 count=1 2> /dev/null | md5sum'
+	    % big_file, shell=True)
+        md5val.append(out.split()[0])
+
+        # One from the last 1MB chunk of 2GB
+        out = check_output(
+            'dd if=%s bs=1M skip=2047 count=1 2> /dev/null | md5sum'
+	    % big_file, shell=True)
+        md5val.append(out.split()[0])
+
+        # One from the start 1MB chunk from 2GB
+        out = check_output(
+            'dd if=%s bs=1M skip=2048 count=1 2> /dev/null | md5sum'
+	    % big_file, shell=True)
+        md5val.append(out.split()[0])
+
+        # One 1MB chunk crossing the 2GB boundary
+        out = check_output(
+            'dd if=%s bs=512K skip=4095 count=2 2> /dev/null | md5sum'
+	    % big_file, shell=True)
+        md5val.append(out.split()[0])
+
+        umount_fs(fs_type, mount_dir)
+    except CalledProcessError:
+        pytest.skip('Setup failed for filesystem: ' + fs_type)
+        return
+    else:
+        yield [fs_ubtype, fs_img, md5val]
+    finally:
+        umount_fs(fs_type, mount_dir)
+        call('rmdir %s' % mount_dir, shell=True)
+        if fs_img:
+            call('rm -f %s' % fs_img, shell=True)
diff --git a/test/py/tests/test_fs/fstest_defs.py b/test/py/tests/test_fs/fstest_defs.py
new file mode 100644
index 000000000000..f26dd06cacf2
--- /dev/null
+++ b/test/py/tests/test_fs/fstest_defs.py
@@ -0,0 +1,10 @@
+# SPDX-License-Identifier:      GPL-2.0+
+
+# $SMALL_FILE is the name of the 1MB file in the file system image
+SMALL_FILE='1MB.file'
+
+# $BIG_FILE is the name of the 2.5GB file in the file system image
+BIG_FILE='2.5GB.file'
+
+ADDR=0x01000008
+LENGTH=0x00100000
diff --git a/test/py/tests/test_fs/test_basic.py b/test/py/tests/test_fs/test_basic.py
new file mode 100644
index 000000000000..c067cc9ba3f6
--- /dev/null
+++ b/test/py/tests/test_fs/test_basic.py
@@ -0,0 +1,287 @@
+# SPDX-License-Identifier:      GPL-2.0+
+# Copyright (c) 2018, Linaro Limited
+# Author: Takahiro Akashi <takahiro.akashi@linaro.org>
+#
+# U-Boot File System:Basic Test
+
+"""
+This test verifies basic read/write operation on file system.
+"""
+
+import pytest
+import re
+from fstest_defs import *
+
+ at pytest.mark.boardspec('sandbox')
+class TestFsBasic(object):
+    def test_fs1(self, u_boot_console, fs_obj_basic):
+        """
+        Test Case 1 - ls command, listing a root directory and invalid directory
+        """
+        fs_type,fs_img,md5val = fs_obj_basic
+        with u_boot_console.log.section('Test Case 1a - ls'):
+            # Test Case 1 - ls
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%sls host 0:0' % fs_type])
+            assert(re.search('2621440000 *%s' % BIG_FILE, ''.join(output)))
+            assert(re.search('1048576 *%s' % SMALL_FILE, ''.join(output)))
+
+        with u_boot_console.log.section('Test Case 1b - ls (invalid dir)'):
+            # In addition, test with a nonexistent directory to see if we crash.
+            output = u_boot_console.run_command(
+                '%sls host 0:0 invalid_d' % fs_type)
+            if fs_type == 'ext4':
+                assert('Can not find directory' in output)
+            else:
+                assert('' == output)
+
+    def test_fs2(self, u_boot_console, fs_obj_basic):
+        """
+        Test Case 2 - size command for a small file
+        """
+        fs_type,fs_img,md5val = fs_obj_basic
+        with u_boot_console.log.section('Test Case 2a - size (small)'):
+            # 1MB is 0x0010 0000
+            # Test Case 2a - size of small file
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%ssize host 0:0 /%s' % (fs_type, SMALL_FILE),
+                'printenv filesize',
+                'setenv filesize'])
+            assert('filesize=100000' in ''.join(output))
+
+        with u_boot_console.log.section('Test Case 2b - size (/../<file>)'):
+            # Test Case 2b - size of small file via a path using '..'
+            output = u_boot_console.run_command_list([
+                '%ssize host 0:0 /SUBDIR/../%s' % (fs_type, SMALL_FILE),
+                'printenv filesize',
+                'setenv filesize'])
+            assert('filesize=100000' in ''.join(output))
+
+    def test_fs3(self, u_boot_console, fs_obj_basic):
+        """
+        Test Case 3 - size command for a large file
+        """
+        fs_type,fs_img,md5val = fs_obj_basic
+        with u_boot_console.log.section('Test Case 3 - size (large)'):
+            # 2.5GB (1024*1024*2500) is 0x9C40 0000
+            # Test Case 3 - size of big file
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%ssize host 0:0 /%s' % (fs_type, BIG_FILE),
+                'printenv filesize',
+                'setenv filesize'])
+            assert('filesize=9c400000' in ''.join(output))
+
+    def test_fs4(self, u_boot_console, fs_obj_basic):
+        """
+        Test Case 4 - load a small file, 1MB
+        """
+        fs_type,fs_img,md5val = fs_obj_basic
+        with u_boot_console.log.section('Test Case 4 - load (small)'):
+            # Test Case 4a - Read full 1MB of small file
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%sload host 0:0 %x /%s' % (fs_type, ADDR, SMALL_FILE),
+                'printenv filesize'])
+            assert('filesize=100000' in ''.join(output))
+
+            # Test Case 4b - Read full 1MB of small file
+            output = u_boot_console.run_command_list([
+                'md5sum %x $filesize' % ADDR,
+                'setenv filesize'])
+            assert(md5val[0] in ''.join(output))
+
+    def test_fs5(self, u_boot_console, fs_obj_basic):
+        """
+        Test Case 5 - load, reading first 1MB of 3GB file
+        """
+        fs_type,fs_img,md5val = fs_obj_basic
+        with u_boot_console.log.section('Test Case 5 - load (first 1MB)'):
+            # Test Case 5a - First 1MB of big file
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%sload host 0:0 %x /%s %x 0x0' % (fs_type, ADDR, BIG_FILE, LENGTH),
+                'printenv filesize'])
+            assert('filesize=100000' in ''.join(output))
+
+            # Test Case 5b - First 1MB of big file
+            output = u_boot_console.run_command_list([
+                'md5sum %x $filesize' % ADDR,
+                'setenv filesize'])
+            assert(md5val[1] in ''.join(output))
+
+    def test_fs6(self, u_boot_console, fs_obj_basic):
+        """
+        Test Case 6 - load, reading last 1MB of 3GB file
+        """
+        fs_type,fs_img,md5val = fs_obj_basic
+        with u_boot_console.log.section('Test Case 6 - load (last 1MB)'):
+            # fails for ext as no offset support
+            # Test Case 6a - Last 1MB of big file
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%sload host 0:0 %x /%s %x 0x9c300000'
+                    % (fs_type, ADDR, BIG_FILE, LENGTH),
+                'printenv filesize'])
+            assert('filesize=100000' in ''.join(output))
+
+            # Test Case 6b - Last 1MB of big file
+            output = u_boot_console.run_command_list([
+                'md5sum %x $filesize' % ADDR,
+                'setenv filesize'])
+            assert(md5val[2] in ''.join(output))
+
+    def test_fs7(self, u_boot_console, fs_obj_basic):
+        """
+        Test Case 7 - load, 1MB from the last 1MB in 2GB
+        """
+        fs_type,fs_img,md5val = fs_obj_basic
+        with u_boot_console.log.section('Test Case 7 - load (last 1MB in 2GB)'):
+            # fails for ext as no offset support
+            # Test Case 7a - One from the last 1MB chunk of 2GB
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%sload host 0:0 %x /%s %x 0x7ff00000'
+                    % (fs_type, ADDR, BIG_FILE, LENGTH),
+                'printenv filesize'])
+            assert('filesize=100000' in ''.join(output))
+
+            # Test Case 7b - One from the last 1MB chunk of 2GB
+            output = u_boot_console.run_command_list([
+                'md5sum %x $filesize' % ADDR,
+                'setenv filesize'])
+            assert(md5val[3] in ''.join(output))
+
+    def test_fs8(self, u_boot_console, fs_obj_basic):
+        """
+        Test Case 8 - load, reading first 1MB in 2GB
+        """
+        fs_type,fs_img,md5val = fs_obj_basic
+        with u_boot_console.log.section('Test Case 8 - load (first 1MB in 2GB)'):
+            # fails for ext as no offset support
+            # Test Case 8a - One from the start 1MB chunk from 2GB
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%sload host 0:0 %x /%s %x 0x80000000'
+                    % (fs_type, ADDR, BIG_FILE, LENGTH),
+                'printenv filesize'])
+            assert('filesize=100000' in ''.join(output))
+
+            # Test Case 8b - One from the start 1MB chunk from 2GB
+            output = u_boot_console.run_command_list([
+                'md5sum %x $filesize' % ADDR,
+                'setenv filesize'])
+            assert(md5val[4] in ''.join(output))
+
+    def test_fs9(self, u_boot_console, fs_obj_basic):
+        """
+        Test Case 9 - load, 1MB crossing 2GB boundary
+        """
+        fs_type,fs_img,md5val = fs_obj_basic
+        with u_boot_console.log.section('Test Case 9 - load (crossing 2GB boundary)'):
+            # fails for ext as no offset support
+            # Test Case 9a - One 1MB chunk crossing the 2GB boundary
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%sload host 0:0 %x /%s %x 0x7ff80000'
+                    % (fs_type, ADDR, BIG_FILE, LENGTH),
+                'printenv filesize'])
+            assert('filesize=100000' in ''.join(output))
+
+            # Test Case 9b - One 1MB chunk crossing the 2GB boundary
+            output = u_boot_console.run_command_list([
+                'md5sum %x $filesize' % ADDR,
+                'setenv filesize'])
+            assert(md5val[5] in ''.join(output))
+
+    def test_fs10(self, u_boot_console, fs_obj_basic):
+        """
+        Test Case 10 - load, reading beyond file end'):
+        """
+        fs_type,fs_img,md5val = fs_obj_basic
+        with u_boot_console.log.section('Test Case 10 - load (beyond file end)'):
+            # Generic failure case
+            # Test Case 10 - 2MB chunk from the last 1MB of big file
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%sload host 0:0 %x /%s 0x00200000 0x9c300000'
+                    % (fs_type, ADDR, BIG_FILE),
+                'printenv filesize',
+                'md5sum %x $filesize' % ADDR,
+                'setenv filesize'])
+        assert('filesize=100000' in ''.join(output))
+
+    def test_fs11(self, u_boot_console, fs_obj_basic):
+        """
+        Test Case 11 - write'
+        """
+        fs_type,fs_img,md5val = fs_obj_basic
+        with u_boot_console.log.section('Test Case 11 - write'):
+            # Read 1MB from small file
+            # Write it back to test the writes
+            # Test Case 11a - Check that the write succeeded
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%sload host 0:0 %x /%s' % (fs_type, ADDR, SMALL_FILE),
+                '%swrite host 0:0 %x /%s.w $filesize'
+                    % (fs_type, ADDR, SMALL_FILE)])
+            assert('1048576 bytes written' in ''.join(output))
+
+            # Test Case 11b - Check md5 of written to is same
+            # as the one read from
+            output = u_boot_console.run_command_list([
+                '%sload host 0:0 %x /%s.w' % (fs_type, ADDR, SMALL_FILE),
+                'md5sum %x $filesize' % ADDR,
+                'setenv filesize'])
+            assert(md5val[0] in ''.join(output))
+
+    def test_fs12(self, u_boot_console, fs_obj_basic):
+        """
+        Test Case 12 - write to "." directory
+        """
+        fs_type,fs_img,md5val = fs_obj_basic
+        with u_boot_console.log.section('Test Case 12 - write (".")'):
+            # Next test case checks writing a file whose dirent
+            # is the first in the block, which is always true for "."
+            # The write should fail, but the lookup should work
+            # Test Case 12 - Check directory traversal
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%swrite host 0:0 %x /. 0x10' % (fs_type, ADDR)])
+            assert('Unable to write' in ''.join(output))
+
+    def test_fs13(self, u_boot_console, fs_obj_basic):
+        """
+        Test Case 13 - write to a file with "/./<filename>"
+        """
+        fs_type,fs_img,md5val = fs_obj_basic
+        with u_boot_console.log.section('Test Case 13 - write  ("./<file>")'):
+            # Read 1MB from small file
+            # Write it via "same directory", i.e. "." dirent
+            # Test Case 13a - Check directory traversal
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%sload host 0:0 %x /%s' % (fs_type, ADDR, SMALL_FILE),
+                '%swrite host 0:0 %x /./%s2 $filesize'
+                    % (fs_type, ADDR, SMALL_FILE)])
+            assert('1048576 bytes written' in ''.join(output))
+
+            # Test Case 13b - Check md5 of written to is same
+            # as the one read from
+            output = u_boot_console.run_command_list([
+                'mw.b %x 00 100' % ADDR,
+                '%sload host 0:0 %x /./%s2' % (fs_type, ADDR, SMALL_FILE),
+                'md5sum %x $filesize' % ADDR,
+                'setenv filesize'])
+            assert(md5val[0] in ''.join(output))
+
+            # Test Case 13c - Check md5 of written to is same
+            # as the one read from
+            output = u_boot_console.run_command_list([
+                'mw.b %x 00 100' % ADDR,
+                '%sload host 0:0 %x /%s2' % (fs_type, ADDR, SMALL_FILE),
+                'md5sum %x $filesize' % ADDR,
+                'setenv filesize'])
+            assert(md5val[0] in ''.join(output))
-- 
2.18.0

[U-Boot] [PATCH v3 24/26] test/py: fs: add extended write operation test

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

In this commit and the following, test scripts for new filesystem
functionalities introduced by my patch set, "fs: fat: extend FAT write
operations," are provided.

In particular, this patch adds test cases for sub-directory write
and write with non-zero offset.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 test/py/tests/test_fs/conftest.py    |  83 ++++++++++
 test/py/tests/test_fs/fstest_defs.py |   3 +
 test/py/tests/test_fs/test_ext.py    | 224 +++++++++++++++++++++++++++
 3 files changed, 310 insertions(+)
 create mode 100644 test/py/tests/test_fs/test_ext.py

diff --git a/test/py/tests/test_fs/conftest.py b/test/py/tests/test_fs/conftest.py
index 3437accc971f..d2908590be16 100644
--- a/test/py/tests/test_fs/conftest.py
+++ b/test/py/tests/test_fs/conftest.py
@@ -10,6 +10,7 @@ from subprocess import call, check_call, check_output, CalledProcessError
 from fstest_defs import *
 
 supported_fs_basic = ['fat16', 'fat32', 'ext4']
+supported_fs_ext = ['fat16', 'fat32']
 
 #
 # Filesystem test specific setup
@@ -20,6 +21,7 @@ def pytest_addoption(parser):
 
 def pytest_configure(config):
     global supported_fs_basic
+    global supported_fs_ext
 
     def intersect(listA, listB):
         return  [x for x in listA if x in listB]
@@ -28,11 +30,15 @@ def pytest_configure(config):
     if supported_fs:
         print("*** FS TYPE modified: %s" % supported_fs)
         supported_fs_basic =  intersect(supported_fs, supported_fs_basic)
+        supported_fs_ext =  intersect(supported_fs, supported_fs_ext)
 
 def pytest_generate_tests(metafunc):
     if 'fs_obj_basic' in metafunc.fixturenames:
         metafunc.parametrize('fs_obj_basic', supported_fs_basic,
             indirect=True, scope='module')
+    if 'fs_obj_ext' in metafunc.fixturenames:
+        metafunc.parametrize('fs_obj_ext', supported_fs_ext,
+            indirect=True, scope='module')
 
 #
 # Helper functions
@@ -216,3 +222,80 @@ def fs_obj_basic(request, u_boot_config):
         call('rmdir %s' % mount_dir, shell=True)
         if fs_img:
             call('rm -f %s' % fs_img, shell=True)
+
+#
+# Fixture for extended fs test
+#
+# NOTE: yield_fixture was deprecated since pytest-3.0
+ at pytest.yield_fixture()
+def fs_obj_ext(request, u_boot_config):
+    fs_type = request.param
+    fs_img = ''
+
+    fs_ubtype = fstype_to_ubname(fs_type)
+    check_ubconfig(u_boot_config, fs_ubtype)
+
+    mount_dir = u_boot_config.persistent_data_dir + '/mnt'
+
+    min_file = mount_dir + '/' + MIN_FILE
+    tmp_file = mount_dir + '/tmpfile'
+
+    try:
+
+        # 128MiB volume
+        fs_img = mk_fs(u_boot_config, fs_type, 0x8000000, '128MB')
+
+        # Mount the image so we can populate it.
+        check_call('mkdir -p %s' % mount_dir, shell=True)
+        mount_fs(fs_type, fs_img, mount_dir)
+
+        # Create a test directory
+        check_call('mkdir %s/dir1' % mount_dir, shell=True)
+
+        # Create a small file and calculate md5
+        check_call('dd if=/dev/urandom of=%s bs=1K count=20'
+            % min_file, shell=True)
+        out = check_output(
+            'dd if=%s bs=1K 2> /dev/null | md5sum'
+            % min_file, shell=True)
+        md5val = [ out.split()[0] ]
+
+        # Calculate md5sum of Test Case 4
+        check_call('dd if=%s of=%s bs=1K count=20'
+            % (min_file, tmp_file), shell=True)
+        check_call('dd if=%s of=%s bs=1K seek=5 count=20'
+            % (min_file, tmp_file), shell=True)
+        out = check_output('dd if=%s bs=1K 2> /dev/null | md5sum'
+            % tmp_file, shell=True)
+        md5val.append(out.split()[0])
+
+        # Calculate md5sum of Test Case 5
+        check_call('dd if=%s of=%s bs=1K count=20'
+            % (min_file, tmp_file), shell=True)
+        check_call('dd if=%s of=%s bs=1K seek=5 count=5'
+            % (min_file, tmp_file), shell=True)
+        out = check_output('dd if=%s bs=1K 2> /dev/null | md5sum'
+            % tmp_file, shell=True)
+        md5val.append(out.split()[0])
+
+        # Calculate md5sum of Test Case 7
+        check_call('dd if=%s of=%s bs=1K count=20'
+            % (min_file, tmp_file), shell=True)
+        check_call('dd if=%s of=%s bs=1K seek=20 count=20'
+            % (min_file, tmp_file), shell=True)
+        out = check_output('dd if=%s bs=1K 2> /dev/null | md5sum'
+            % tmp_file, shell=True)
+        md5val.append(out.split()[0])
+
+        check_call('rm %s' % tmp_file, shell=True)
+        umount_fs(fs_type, mount_dir)
+    except CalledProcessError:
+        pytest.skip('Setup failed for filesystem: ' + fs_type)
+        return
+    else:
+        yield [fs_ubtype, fs_img, md5val]
+    finally:
+        umount_fs(fs_type, mount_dir)
+        call('rmdir %s' % mount_dir, shell=True)
+        if fs_img:
+            call('rm -f %s' % fs_img, shell=True)
diff --git a/test/py/tests/test_fs/fstest_defs.py b/test/py/tests/test_fs/fstest_defs.py
index f26dd06cacf2..5f107562d952 100644
--- a/test/py/tests/test_fs/fstest_defs.py
+++ b/test/py/tests/test_fs/fstest_defs.py
@@ -1,5 +1,8 @@
 # SPDX-License-Identifier:      GPL-2.0+
 
+# $MIN_FILE is the name of the 20KB file in the file system image
+MIN_FILE='testfile'
+
 # $SMALL_FILE is the name of the 1MB file in the file system image
 SMALL_FILE='1MB.file'
 
diff --git a/test/py/tests/test_fs/test_ext.py b/test/py/tests/test_fs/test_ext.py
new file mode 100644
index 000000000000..38217d08bf64
--- /dev/null
+++ b/test/py/tests/test_fs/test_ext.py
@@ -0,0 +1,224 @@
+# SPDX-License-Identifier:      GPL-2.0+
+# Copyright (c) 2018, Linaro Limited
+# Author: Takahiro Akashi <takahiro.akashi@linaro.org>
+#
+# U-Boot File System:Exntented Test
+
+"""
+This test verifies extended write operation on file system.
+"""
+
+import pytest
+import re
+from fstest_defs import *
+
+ at pytest.mark.boardspec('sandbox')
+class TestFsExt(object):
+    def test_fs_ext1(self, u_boot_console, fs_obj_ext):
+        """
+        Test Case 1 - write a file with absolute path
+        """
+        fs_type,fs_img,md5val = fs_obj_ext
+        with u_boot_console.log.section('Test Case 1 - write with abs path'):
+            # Test Case 1a - Check if command successfully returned
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%sload host 0:0 %x /%s' % (fs_type, ADDR, MIN_FILE),
+                '%swrite host 0:0 %x /dir1/%s.w1 $filesize'
+                    % (fs_type, ADDR, MIN_FILE)])
+            assert('20480 bytes written' in ''.join(output))
+
+            # Test Case 1b - Check md5 of file content
+            output = u_boot_console.run_command_list([
+                'mw.b %x 00 100' % ADDR,
+                '%sload host 0:0 %x /dir1/%s.w1' % (fs_type, ADDR, MIN_FILE),
+                'md5sum %x $filesize' % ADDR,
+                'setenv filesize'])
+            assert(md5val[0] in ''.join(output))
+
+    def test_fs_ext2(self, u_boot_console, fs_obj_ext):
+        """
+        Test Case 2 - write to a file with relative path
+        """
+        fs_type,fs_img,md5val = fs_obj_ext
+        with u_boot_console.log.section('Test Case 2 - write with rel path'):
+            # Test Case 2a - Check if command successfully returned
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%sload host 0:0 %x /%s' % (fs_type, ADDR, MIN_FILE),
+                '%swrite host 0:0 %x dir1/%s.w2 $filesize'
+                    % (fs_type, ADDR, MIN_FILE)])
+            assert('20480 bytes written' in ''.join(output))
+
+            # Test Case 2b - Check md5 of file content
+            output = u_boot_console.run_command_list([
+                'mw.b %x 00 100' % ADDR,
+                '%sload host 0:0 %x dir1/%s.w2' % (fs_type, ADDR, MIN_FILE),
+                'md5sum %x $filesize' % ADDR,
+                'setenv filesize'])
+            assert(md5val[0] in ''.join(output))
+
+    def test_fs_ext3(self, u_boot_console, fs_obj_ext):
+        """
+        Test Case 3 - write to a file with invalid path
+        """
+        fs_type,fs_img,md5val = fs_obj_ext
+        with u_boot_console.log.section('Test Case 3 - write with invalid path'):
+            # Test Case 3 - Check if command expectedly failed
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%sload host 0:0 %x /%s' % (fs_type, ADDR, MIN_FILE),
+                '%swrite host 0:0 %x /dir1/none/%s.w3 $filesize'
+                    % (fs_type, ADDR, MIN_FILE)])
+            assert('Unable to write "/dir1/none/' in ''.join(output))
+
+    def test_fs_ext4(self, u_boot_console, fs_obj_ext):
+        """
+        Test Case 4 - write at non-zero offset, enlarging file size
+        """
+        fs_type,fs_img,md5val = fs_obj_ext
+        with u_boot_console.log.section('Test Case 4 - write at non-zero offset, enlarging file size'):
+            # Test Case 4a - Check if command successfully returned
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%sload host 0:0 %x /%s' % (fs_type, ADDR, MIN_FILE),
+                '%swrite host 0:0 %x /dir1/%s.w4 $filesize'
+                    % (fs_type, ADDR, MIN_FILE)])
+            output = u_boot_console.run_command(
+                '%swrite host 0:0 %x /dir1/%s.w4 $filesize 0x1400'
+                    % (fs_type, ADDR, MIN_FILE))
+            assert('20480 bytes written' in output)
+
+            # Test Case 4b - Check size of written file
+            output = u_boot_console.run_command_list([
+                '%ssize host 0:0 /dir1/%s.w4' % (fs_type, MIN_FILE),
+                'printenv filesize',
+                'setenv filesize'])
+            assert('filesize=6400' in ''.join(output))
+
+            # Test Case 4c - Check md5 of file content
+            output = u_boot_console.run_command_list([
+                'mw.b %x 00 100' % ADDR,
+                '%sload host 0:0 %x /dir1/%s.w4' % (fs_type, ADDR, MIN_FILE),
+                'md5sum %x $filesize' % ADDR,
+                'setenv filesize'])
+            assert(md5val[1] in ''.join(output))
+
+    def test_fs_ext5(self, u_boot_console, fs_obj_ext):
+        """
+        Test Case 5 - write at non-zero offset, shrinking file size
+        """
+        fs_type,fs_img,md5val = fs_obj_ext
+        with u_boot_console.log.section('Test Case 5 - write at non-zero offset, shrinking file size'):
+            # Test Case 5a - Check if command successfully returned
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%sload host 0:0 %x /%s' % (fs_type, ADDR, MIN_FILE),
+                '%swrite host 0:0 %x /dir1/%s.w5 $filesize'
+                    % (fs_type, ADDR, MIN_FILE)])
+            output = u_boot_console.run_command(
+                '%swrite host 0:0 %x /dir1/%s.w5 0x1400 0x1400'
+                    % (fs_type, ADDR, MIN_FILE))
+            assert('5120 bytes written' in output)
+
+            # Test Case 5b - Check size of written file
+            output = u_boot_console.run_command_list([
+                '%ssize host 0:0 /dir1/%s.w5' % (fs_type, MIN_FILE),
+                'printenv filesize',
+                'setenv filesize'])
+            assert('filesize=2800' in ''.join(output))
+
+            # Test Case 5c - Check md5 of file content
+            output = u_boot_console.run_command_list([
+                'mw.b %x 00 100' % ADDR,
+                '%sload host 0:0 %x /dir1/%s.w5' % (fs_type, ADDR, MIN_FILE),
+                'md5sum %x $filesize' % ADDR,
+                'setenv filesize'])
+            assert(md5val[2] in ''.join(output))
+
+    def test_fs_ext6(self, u_boot_console, fs_obj_ext):
+        """
+        Test Case 6 - write nothing at the start, truncating to zero
+        """
+        fs_type,fs_img,md5val = fs_obj_ext
+        with u_boot_console.log.section('Test Case 6 - write nothing at the start, truncating to zero'):
+            # Test Case 6a - Check if command successfully returned
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%sload host 0:0 %x /%s' % (fs_type, ADDR, MIN_FILE),
+                '%swrite host 0:0 %x /dir1/%s.w6 $filesize'
+                    % (fs_type, ADDR, MIN_FILE)])
+            output = u_boot_console.run_command(
+                '%swrite host 0:0 %x /dir1/%s.w6 0 0'
+                    % (fs_type, ADDR, MIN_FILE))
+            assert('0 bytes written' in output)
+
+            # Test Case 6b - Check size of written file
+            output = u_boot_console.run_command_list([
+                '%ssize host 0:0 /dir1/%s.w6' % (fs_type, MIN_FILE),
+                'printenv filesize',
+                'setenv filesize'])
+            assert('filesize=0' in ''.join(output))
+
+    def test_fs_ext7(self, u_boot_console, fs_obj_ext):
+        """
+        Test Case 7 - write at the end (append)
+        """
+        fs_type,fs_img,md5val = fs_obj_ext
+        with u_boot_console.log.section('Test Case 7 - write at the end (append)'):
+            # Test Case 7a - Check if command successfully returned
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%sload host 0:0 %x /%s' % (fs_type, ADDR, MIN_FILE),
+                '%swrite host 0:0 %x /dir1/%s.w7 $filesize'
+                    % (fs_type, ADDR, MIN_FILE)])
+            output = u_boot_console.run_command(
+                '%swrite host 0:0 %x /dir1/%s.w7 $filesize $filesize'
+                    % (fs_type, ADDR, MIN_FILE))
+            assert('20480 bytes written' in output)
+
+            # Test Case 7b - Check size of written file
+            output = u_boot_console.run_command_list([
+                '%ssize host 0:0 /dir1/%s.w7' % (fs_type, MIN_FILE),
+                'printenv filesize',
+                'setenv filesize'])
+            assert('filesize=a000' in ''.join(output))
+
+            # Test Case 7c - Check md5 of file content
+            output = u_boot_console.run_command_list([
+                'mw.b %x 00 100' % ADDR,
+                '%sload host 0:0 %x /dir1/%s.w7' % (fs_type, ADDR, MIN_FILE),
+                'md5sum %x $filesize' % ADDR,
+                'setenv filesize'])
+            assert(md5val[3] in ''.join(output))
+
+    def test_fs_ext8(self, u_boot_console, fs_obj_ext):
+        """
+        Test Case 8 - write at offset beyond the end of file
+        """
+        fs_type,fs_img,md5val = fs_obj_ext
+        with u_boot_console.log.section('Test Case 8 - write beyond the end'):
+            # Test Case 8a - Check if command expectedly failed
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%sload host 0:0 %x /%s' % (fs_type, ADDR, MIN_FILE),
+                '%swrite host 0:0 %x /dir1/%s.w8 $filesize'
+                    % (fs_type, ADDR, MIN_FILE)])
+            output = u_boot_console.run_command(
+                '%swrite host 0:0 %x /dir1/%s.w8 0x1400 %x'
+                    % (fs_type, ADDR, MIN_FILE, 0x100000 + 0x1400))
+            assert('Unable to write "/dir1' in output)
+
+    def test_fs_ext9(self, u_boot_console, fs_obj_ext):
+        """
+        Test Case 9 - write to a non-existing file at non-zero offset
+        """
+        fs_type,fs_img,md5val = fs_obj_ext
+        with u_boot_console.log.section('Test Case 9 - write to non-existing file with non-zero offset'):
+            # Test Case 9a - Check if command expectedly failed
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%sload host 0:0 %x /%s' % (fs_type, ADDR, MIN_FILE),
+                '%swrite host 0:0 %x /dir1/%s.w9 0x1400 0x1400'
+                    % (fs_type, ADDR, MIN_FILE)])
+            assert('Unable to write "/dir1' in ''.join(output))
-- 
2.18.0

[U-Boot] [PATCH v3 25/26] test/py: fs: add fstest/mkdir test

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

In this commit, test cases for mkdir interfaces are added as part of
"test_fs" test suite.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 test/py/tests/test_fs/conftest.py   |  29 +++++++
 test/py/tests/test_fs/test_mkdir.py | 112 ++++++++++++++++++++++++++++
 2 files changed, 141 insertions(+)
 create mode 100644 test/py/tests/test_fs/test_mkdir.py

diff --git a/test/py/tests/test_fs/conftest.py b/test/py/tests/test_fs/conftest.py
index d2908590be16..71abf8fa4222 100644
--- a/test/py/tests/test_fs/conftest.py
+++ b/test/py/tests/test_fs/conftest.py
@@ -11,6 +11,7 @@ from fstest_defs import *
 
 supported_fs_basic = ['fat16', 'fat32', 'ext4']
 supported_fs_ext = ['fat16', 'fat32']
+supported_fs_mkdir = ['fat16', 'fat32']
 
 #
 # Filesystem test specific setup
@@ -22,6 +23,7 @@ def pytest_addoption(parser):
 def pytest_configure(config):
     global supported_fs_basic
     global supported_fs_ext
+    global supported_fs_mkdir
 
     def intersect(listA, listB):
         return  [x for x in listA if x in listB]
@@ -31,6 +33,7 @@ def pytest_configure(config):
         print("*** FS TYPE modified: %s" % supported_fs)
         supported_fs_basic =  intersect(supported_fs, supported_fs_basic)
         supported_fs_ext =  intersect(supported_fs, supported_fs_ext)
+        supported_fs_mkdir =  intersect(supported_fs, supported_fs_mkdir)
 
 def pytest_generate_tests(metafunc):
     if 'fs_obj_basic' in metafunc.fixturenames:
@@ -39,6 +42,9 @@ def pytest_generate_tests(metafunc):
     if 'fs_obj_ext' in metafunc.fixturenames:
         metafunc.parametrize('fs_obj_ext', supported_fs_ext,
             indirect=True, scope='module')
+    if 'fs_obj_mkdir' in metafunc.fixturenames:
+        metafunc.parametrize('fs_obj_mkdir', supported_fs_mkdir,
+            indirect=True, scope='module')
 
 #
 # Helper functions
@@ -299,3 +305,26 @@ def fs_obj_ext(request, u_boot_config):
         call('rmdir %s' % mount_dir, shell=True)
         if fs_img:
             call('rm -f %s' % fs_img, shell=True)
+
+#
+# Fixture for mkdir test
+#
+# NOTE: yield_fixture was deprecated since pytest-3.0
+ at pytest.yield_fixture()
+def fs_obj_mkdir(request, u_boot_config):
+    fs_type = request.param
+    fs_img = ''
+
+    fs_ubtype = fstype_to_ubname(fs_type)
+    check_ubconfig(u_boot_config, fs_ubtype)
+
+    try:
+        # 128MiB volume
+        fs_img = mk_fs(u_boot_config, fs_type, 0x8000000, '128MB')
+    except:
+        pytest.skip('Setup failed for filesystem: ' + fs_type)
+    else:
+        yield [fs_ubtype, fs_img]
+    finally:
+        if fs_img:
+            call('rm -f %s' % fs_img, shell=True)
diff --git a/test/py/tests/test_fs/test_mkdir.py b/test/py/tests/test_fs/test_mkdir.py
new file mode 100644
index 000000000000..d9da97b56b5e
--- /dev/null
+++ b/test/py/tests/test_fs/test_mkdir.py
@@ -0,0 +1,112 @@
+# SPDX-License-Identifier:      GPL-2.0+
+# Copyright (c) 2018, Linaro Limited
+# Author: Takahiro Akashi <takahiro.akashi@linaro.org>
+#
+# U-Boot File System:mkdir Test
+
+"""
+This test verifies mkdir operation on file system.
+"""
+
+import pytest
+
+ at pytest.mark.boardspec('sandbox')
+class TestMkdir(object):
+    def test_mkdir1(self, u_boot_console, fs_obj_mkdir):
+        """
+        Test Case 1 - create a directory under a root
+        """
+        fs_type,fs_img = fs_obj_mkdir
+        with u_boot_console.log.section('Test Case 1 - mkdir'):
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%smkdir host 0:0 dir1' % fs_type,
+                '%sls host 0:0 /' % fs_type])
+            assert('dir1/' in ''.join(output))
+
+            output = u_boot_console.run_command(
+                '%sls host 0:0 dir1' % fs_type)
+            assert('./'   in output)
+            assert('../'  in output)
+
+    def test_mkdir2(self, u_boot_console, fs_obj_mkdir):
+        """
+        Test Case 2 - create a directory under a sub-directory
+        """
+        fs_type,fs_img = fs_obj_mkdir
+        with u_boot_console.log.section('Test Case 2 - mkdir (sub-sub directory)'):
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%smkdir host 0:0 dir1/dir2' % fs_type,
+                '%sls host 0:0 dir1' % fs_type])
+            assert('dir2/' in ''.join(output))
+
+            output = u_boot_console.run_command(
+                '%sls host 0:0 dir1/dir2' % fs_type)
+            assert('./'   in output)
+            assert('../'  in output)
+
+    def test_mkdir3(self, u_boot_console, fs_obj_mkdir):
+        """
+        Test Case 3 - trying to create a directory with a non-existing
+        path should fail
+        """
+        fs_type,fs_img = fs_obj_mkdir
+        with u_boot_console.log.section('Test Case 3 - mkdir (non-existing path)'):
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%smkdir host 0:0 none/dir3' % fs_type])
+            assert('Unable to create a directory' in ''.join(output))
+
+    def test_mkdir4(self, u_boot_console, fs_obj_mkdir):
+        """
+        Test Case 4 - trying to create "." should fail
+        """
+        fs_type,fs_img = fs_obj_mkdir
+        with u_boot_console.log.section('Test Case 4 - mkdir (".")'):
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%smkdir host 0:0 .' % fs_type])
+            assert('Unable to create a directory' in ''.join(output))
+
+    def test_mkdir5(self, u_boot_console, fs_obj_mkdir):
+        """
+        Test Case 5 - trying to create ".." should fail
+        """
+        fs_type,fs_img = fs_obj_mkdir
+        with u_boot_console.log.section('Test Case 5 - mkdir ("..")'):
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%smkdir host 0:0 ..' % fs_type])
+            assert('Unable to create a directory' in ''.join(output))
+
+    def test_mkdir6(self, u_boot_console, fs_obj_mkdir):
+        """
+        'Test Case 6 - create as many directories as amount of directory
+        entries goes beyond a cluster size)'
+        """
+        fs_type,fs_img = fs_obj_mkdir
+        with u_boot_console.log.section('Test Case 6 - mkdir (create many)'):
+            output = u_boot_console.run_command_list([
+                'host bind 0 %s' % fs_img,
+                '%smkdir host 0:0 dir6' % fs_type,
+                '%sls host 0:0 /' % fs_type])
+            assert('dir6/' in ''.join(output))
+
+            for i in range(0, 20):
+                output = u_boot_console.run_command(
+                    '%smkdir host 0:0 dir6/0123456789abcdef%02x'
+                    % (fs_type, i))
+            output = u_boot_console.run_command('%sls host 0:0 dir6' % fs_type)
+            assert('0123456789abcdef00/'  in output)
+            assert('0123456789abcdef13/'  in output)
+
+            output = u_boot_console.run_command(
+                '%sls host 0:0 dir6/0123456789abcdef13/.' % fs_type)
+            assert('./'   in output)
+            assert('../'  in output)
+
+            output = u_boot_console.run_command(
+                '%sls host 0:0 dir6/0123456789abcdef13/..' % fs_type)
+            assert('0123456789abcdef00/'  in output)
+            assert('0123456789abcdef13/'  in output)
-- 
2.18.0

[U-Boot] [PATCH v3 01/26] fs: fat: guard the content of include/fat.h

[Alexander Graf]

On 11.09.18 08:58, Akashi, Takahiro wrote:
> From: AKASHI Takahiro <takahiro.akashi@linaro.org>
> 
> The whole content of include/fat.h is private to FAT implementation
> and then should be guarded with CONFIG_FS_FAT.
> 
> Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>

I thought we could drop this patch now?

If you really need it, please state why in the patch description and
make sure to include common.h before you do the #ifdef on CONFIG_FS_FAT.
Otherwise the symbol might not be declared.


Alex

> ---
>  include/fat.h | 3 +++
>  1 file changed, 3 insertions(+)
> 
> diff --git a/include/fat.h b/include/fat.h
> index 09e142368585..c02839dcb040 100644
> --- a/include/fat.h
> +++ b/include/fat.h
> @@ -9,6 +9,8 @@
>  #ifndef _FAT_H_
>  #define _FAT_H_
>  
> +#ifdef CONFIG_FS_FAT
> +
>  #include <asm/byteorder.h>
>  #include <fs.h>
>  
> @@ -202,4 +204,5 @@ int fat_opendir(const char *filename, struct fs_dir_stream **dirsp);
>  int fat_readdir(struct fs_dir_stream *dirs, struct fs_dirent **dentp);
>  void fat_closedir(struct fs_dir_stream *dirs);
>  void fat_close(void);
> +#endif /* CONFIG_FS_FAT */
>  #endif /* _FAT_H_ */
> 

[U-Boot] [PATCH v3 10/26] fs: fat: support write with non-zero offset

[Alexander Graf]

On 11.09.18 08:59, Akashi, Takahiro wrote:
> From: AKASHI Takahiro <takahiro.akashi@linaro.org>
> 
> In this patch, all the necessary code for allowing for a file offset
> at write is implemented. What plays a major roll here is get_set_cluster(),
> which, in contrast to its counterpart, set_cluster(), only operates on
> already-allocated clusters, overwriting with data.
> 
> So, with a file offset specified, set_contents() seeks and writes data
> with set_get_cluster() until the end of a file, and, once it reaches
> there, continues writing with set_cluster() for the rest.
> 
> Please note that a file will be trimmed as a result of write operation if
> write ends before reaching file's end. This is an intended behavior
> in order to maintain compatibility with the current interface.
> 
> Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
> ---
>  fs/fat/fat_write.c | 288 ++++++++++++++++++++++++++++++++++++++++++---
>  1 file changed, 273 insertions(+), 15 deletions(-)
> 
> diff --git a/fs/fat/fat_write.c b/fs/fat/fat_write.c
> index c22d8c7a46a1..651c7866debc 100644
> --- a/fs/fat/fat_write.c
> +++ b/fs/fat/fat_write.c
> @@ -450,6 +450,121 @@ set_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer,
>  	return 0;
>  }
>  
> +static __u8 tmpbuf_cluster[MAX_CLUSTSIZE] __aligned(ARCH_DMA_MINALIGN);

I'm not sure all systems that allow FAT writing will like the additional
overhead this will incur. Have you thrown your patch set into buildman
to check all boards successfully build?


Alex

[U-Boot] [PATCH v3 01/26] fs: fat: guard the content of include/fat.h

[Akashi, Takahiro]

On Tue, Sep 11, 2018 at 12:12:53PM +0200, Alexander Graf wrote:
> 
> 
> On 11.09.18 08:58, Akashi, Takahiro wrote:
> > From: AKASHI Takahiro <takahiro.akashi@linaro.org>
> > 
> > The whole content of include/fat.h is private to FAT implementation
> > and then should be guarded with CONFIG_FS_FAT.
> > 
> > Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
> 
> I thought we could drop this patch now?

No, we can't as I said in
https://lists.denx.de/pipermail/u-boot/2018-September/340233.html

> If you really need it, please state why in the patch description and

Oops, I've forgot to do so.

> make sure to include common.h before you do the #ifdef on CONFIG_FS_FAT.
> Otherwise the symbol might not be declared.

Forgot it, too :)

Can I re-submit only this patch(01/26) rather than my whole patch set?

-Takahiro Akashi


 
> Alex
> 
> > ---
> >  include/fat.h | 3 +++
> >  1 file changed, 3 insertions(+)
> > 
> > diff --git a/include/fat.h b/include/fat.h
> > index 09e142368585..c02839dcb040 100644
> > --- a/include/fat.h
> > +++ b/include/fat.h
> > @@ -9,6 +9,8 @@
> >  #ifndef _FAT_H_
> >  #define _FAT_H_
> >  
> > +#ifdef CONFIG_FS_FAT
> > +
> >  #include <asm/byteorder.h>
> >  #include <fs.h>
> >  
> > @@ -202,4 +204,5 @@ int fat_opendir(const char *filename, struct fs_dir_stream **dirsp);
> >  int fat_readdir(struct fs_dir_stream *dirs, struct fs_dirent **dentp);
> >  void fat_closedir(struct fs_dir_stream *dirs);
> >  void fat_close(void);
> > +#endif /* CONFIG_FS_FAT */
> >  #endif /* _FAT_H_ */
> > 

[U-Boot] [PATCH v3 10/26] fs: fat: support write with non-zero offset

[Akashi, Takahiro]

On Tue, Sep 11, 2018 at 01:09:43PM +0200, Alexander Graf wrote:
> 
> 
> On 11.09.18 08:59, Akashi, Takahiro wrote:
> > From: AKASHI Takahiro <takahiro.akashi@linaro.org>
> > 
> > In this patch, all the necessary code for allowing for a file offset
> > at write is implemented. What plays a major roll here is get_set_cluster(),
> > which, in contrast to its counterpart, set_cluster(), only operates on
> > already-allocated clusters, overwriting with data.
> > 
> > So, with a file offset specified, set_contents() seeks and writes data
> > with set_get_cluster() until the end of a file, and, once it reaches
> > there, continues writing with set_cluster() for the rest.
> > 
> > Please note that a file will be trimmed as a result of write operation if
> > write ends before reaching file's end. This is an intended behavior
> > in order to maintain compatibility with the current interface.
> > 
> > Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
> > ---
> >  fs/fat/fat_write.c | 288 ++++++++++++++++++++++++++++++++++++++++++---
> >  1 file changed, 273 insertions(+), 15 deletions(-)
> > 
> > diff --git a/fs/fat/fat_write.c b/fs/fat/fat_write.c
> > index c22d8c7a46a1..651c7866debc 100644
> > --- a/fs/fat/fat_write.c
> > +++ b/fs/fat/fat_write.c
> > @@ -450,6 +450,121 @@ set_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer,
> >  	return 0;
> >  }
> >  
> > +static __u8 tmpbuf_cluster[MAX_CLUSTSIZE] __aligned(ARCH_DMA_MINALIGN);
> 
> I'm not sure all systems that allow FAT writing will like the additional
> overhead this will incur.

Which part are you seeing as "overhead"?
I know it's ugly but the same technique is also used in fat.c :)

> Have you thrown your patch set into buildman
> to check all boards successfully build?

No, not at all.

Thanks,
-Takahiro Akashi
> 
> 
> Alex

[U-Boot] [PATCH v3 01/26] fs: fat: guard the content of include/fat.h

[Alexander Graf]

On 12.09.18 02:53, Akashi, Takahiro wrote:
> On Tue, Sep 11, 2018 at 12:12:53PM +0200, Alexander Graf wrote:
>>
>>
>> On 11.09.18 08:58, Akashi, Takahiro wrote:
>>> From: AKASHI Takahiro <takahiro.akashi@linaro.org>
>>>
>>> The whole content of include/fat.h is private to FAT implementation
>>> and then should be guarded with CONFIG_FS_FAT.
>>>
>>> Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
>>
>> I thought we could drop this patch now?
> 
> No, we can't as I said in
> https://lists.denx.de/pipermail/u-boot/2018-September/340233.html
> 
>> If you really need it, please state why in the patch description and
> 
> Oops, I've forgot to do so.
> 
>> make sure to include common.h before you do the #ifdef on CONFIG_FS_FAT.
>> Otherwise the symbol might not be declared.
> 
> Forgot it, too :)
> 
> Can I re-submit only this patch(01/26) rather than my whole patch set?

Sure. All other patches are applied.


Alex

[U-Boot] [PATCH v3 10/26] fs: fat: support write with non-zero offset

[Alexander Graf]

On 12.09.18 04:14, Akashi, Takahiro wrote:
> On Tue, Sep 11, 2018 at 01:09:43PM +0200, Alexander Graf wrote:
>>
>>
>> On 11.09.18 08:59, Akashi, Takahiro wrote:
>>> From: AKASHI Takahiro <takahiro.akashi@linaro.org>
>>>
>>> In this patch, all the necessary code for allowing for a file offset
>>> at write is implemented. What plays a major roll here is get_set_cluster(),
>>> which, in contrast to its counterpart, set_cluster(), only operates on
>>> already-allocated clusters, overwriting with data.
>>>
>>> So, with a file offset specified, set_contents() seeks and writes data
>>> with set_get_cluster() until the end of a file, and, once it reaches
>>> there, continues writing with set_cluster() for the rest.
>>>
>>> Please note that a file will be trimmed as a result of write operation if
>>> write ends before reaching file's end. This is an intended behavior
>>> in order to maintain compatibility with the current interface.
>>>
>>> Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
>>> ---
>>>  fs/fat/fat_write.c | 288 ++++++++++++++++++++++++++++++++++++++++++---
>>>  1 file changed, 273 insertions(+), 15 deletions(-)
>>>
>>> diff --git a/fs/fat/fat_write.c b/fs/fat/fat_write.c
>>> index c22d8c7a46a1..651c7866debc 100644
>>> --- a/fs/fat/fat_write.c
>>> +++ b/fs/fat/fat_write.c
>>> @@ -450,6 +450,121 @@ set_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer,
>>>  	return 0;
>>>  }
>>>  
>>> +static __u8 tmpbuf_cluster[MAX_CLUSTSIZE] __aligned(ARCH_DMA_MINALIGN);
>>
>> I'm not sure all systems that allow FAT writing will like the additional
>> overhead this will incur.
> 
> Which part are you seeing as "overhead"?
> I know it's ugly but the same technique is also used in fat.c :)

Yeah, it just grows .bss by the cluster size. But I didn't run into any
board yet that complained, so I guess we're good.

> 
>> Have you thrown your patch set into buildman
>> to check all boards successfully build?
> 
> No, not at all.

You turned out lucky then :). If you don't want to run travis (which
basically just calls buildman), you can run buildman locally as well to
verify that the code still builds fine on all targets after your changes.


Alex

[U-Boot] [PATCH v3.1 01/26] fs: fat: guard the content of include/fat.h

[Akashi, Takahiro]

From: AKASHI Takahiro <takahiro.akashi@linaro.org>

The whole content of include/fat.h should be guarded with CONFIG_FS_FAT.

This is necessary specifically because fs/fs.c unconditionally includes
fat.h, which refers to a config symbol, CONFIG_FS_FAT_MAX_CLUSTSIZE.
So if CONFIG_FS_FAT, and thus CONFIG_FS_FAT_MAX_CLUSTSIZE, is not
defined, fs/fs.c will fail to compile.

Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
---
 include/fat.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/include/fat.h b/include/fat.h
index 09e142368585..8bc280e872ba 100644
--- a/include/fat.h
+++ b/include/fat.h
@@ -9,6 +9,9 @@
 #ifndef _FAT_H_
 #define _FAT_H_
 
+#include <common.h>
+#ifdef CONFIG_FS_FAT
+
 #include <asm/byteorder.h>
 #include <fs.h>
 
@@ -202,4 +205,5 @@ int fat_opendir(const char *filename, struct fs_dir_stream **dirsp);
 int fat_readdir(struct fs_dir_stream *dirs, struct fs_dirent **dentp);
 void fat_closedir(struct fs_dir_stream *dirs);
 void fat_close(void);
+#endif /* CONFIG_FS_FAT */
 #endif /* _FAT_H_ */
-- 
2.18.0

[U-Boot] [PATCH v3.1 01/26] fs: fat: guard the content of include/fat.h

[Alexander Graf]

On 12.09.18 08:55, Akashi, Takahiro wrote:
> From: AKASHI Takahiro <takahiro.akashi@linaro.org>
> 
> The whole content of include/fat.h should be guarded with CONFIG_FS_FAT.
> 
> This is necessary specifically because fs/fs.c unconditionally includes
> fat.h, which refers to a config symbol, CONFIG_FS_FAT_MAX_CLUSTSIZE.
> So if CONFIG_FS_FAT, and thus CONFIG_FS_FAT_MAX_CLUSTSIZE, is not
> defined, fs/fs.c will fail to compile.

I don't see that define used anywhere outside of FAT code, so I still
don't understand why we need this patch.


Alex

[U-Boot] [PATCH v3.1 01/26] fs: fat: guard the content of include/fat.h

[Akashi, Takahiro]

On Sun, Sep 23, 2018 at 04:42:17PM +0200, Alexander Graf wrote:
> 
> 
> On 12.09.18 08:55, Akashi, Takahiro wrote:
> > From: AKASHI Takahiro <takahiro.akashi@linaro.org>
> > 
> > The whole content of include/fat.h should be guarded with CONFIG_FS_FAT.
> > 
> > This is necessary specifically because fs/fs.c unconditionally includes
> > fat.h, which refers to a config symbol, CONFIG_FS_FAT_MAX_CLUSTSIZE.
> > So if CONFIG_FS_FAT, and thus CONFIG_FS_FAT_MAX_CLUSTSIZE, is not
> > defined, fs/fs.c will fail to compile.
> 
> I don't see that define used anywhere outside of FAT code, so I still
> don't understand why we need this patch.

Try to compile u-boot without CONFIG_FS_FAT.
You will find out what I (and originally Heinrich) meant.

Thanks,
-Takahiro Akashi

> 
> Alex

[U-Boot] [PATCH v3 10/26] fs: fat: support write with non-zero offset

[Jean-Jacques Hiblot]

This sometimes breaks fat writes.

The tests is simple: load a file from tftp, write it on MMC, read it 
back and compare

I can provide an image of the partition if needed.

JJ


=> setenv autoload no; dhcp; setenv serverip 192.168.1.42; tftp 
$loadaddr test; echo WRITING !; fatwrite mmc 0 $loadaddr u-boot.img 
$filesize; mmc dev 1; mmc dev 0 ; echo READING! ; fatload mmc 0 
0x83000000 u-boot.img; cmp.b 0x83000000 $loadae
link up on port 0, speed 1000, full duplex
BOOTP broadcast 1
DHCP client bound to address 192.168.1.27 (2004 ms)
link up on port 0, speed 1000, full duplex
Using ethernet at 48484000 device
TFTP from server 192.168.1.42; our IP address is 192.168.1.27
Filename 'test'.
Load address: 0x82000000
Loading: #################################################################
          #######
          5.2 MiB/s
done
Bytes transferred = 1048576 (100000 hex)
WRITING !
writing u-boot.img
FAT16, fat_sect: 1, fatlength: 200
Rootdir begins at cluster: -6, sector: 401, offset: 32200
Data begins at: 425
Sector size: 512, cluster size: 4
FAT read(sect=401), clust_size=4, DIRENTSPERBLOCK=16
1048576 bytes
FAT16: entry: 0x0000020d = 525, offset: 0x020d = 525
debug: evicting -1, dirty: 0
FAT16: ret: 0x0000020e, entry: 0x0000020d, offset: 0x020d
FAT16: entry: 0x0000020e = 526, offset: 0x020e = 526
FAT16: ret: 0x0000020f, entry: 0x0000020e, offset: 0x020e
FAT16: entry: 0x0000020f = 527, offset: 0x020f = 527
FAT16: ret: 0x00000210, entry: 0x0000020f, offset: 0x020f
FAT16: entry: 0x00000210 = 528, offset: 0x0210 = 528
FAT16: ret: 0x00000211, entry: 0x00000210, offset: 0x0210
FAT16: entry: 0x00000211 = 529, offset: 0x0211 = 529
FAT16: ret: 0x00000212, entry: 0x00000211, offset: 0x0211
FAT16: entry: 0x00000212 = 530, offset: 0x0212 = 530
FAT16: ret: 0x00000213, entry: 0x00000212, offset: 0x0212
FAT16: entry: 0x00000213 = 531, offset: 0x0213 = 531
FAT16: ret: 0x00000214, entry: 0x00000213, offset: 0x0213
FAT16: entry: 0x00000214 = 532, offset: 0x0214 = 532
FAT16: ret: 0x00000215, entry: 0x00000214, offset: 0x0214
FAT16: entry: 0x00000215 = 533, offset: 0x0215 = 533
FAT16: ret: 0x00000216, entry: 0x00000215, offset: 0x0215
FAT16: entry: 0x00000216 = 534, offset: 0x0216 = 534
FAT16: ret: 0x00000217, entry: 0x00000216, offset: 0x0216
FAT16: entry: 0x00000217 = 535, offset: 0x0217 = 535
FAT16: ret: 0x00000218, entry: 0x00000217, offset: 0x0217
FAT16: entry: 0x00000218 = 536, offset: 0x0218 = 536
FAT16: ret: 0x00000219, entry: 0x00000218, offset: 0x0218
FAT16: entry: 0x00000219 = 537, offset: 0x0219 = 537
FAT16: ret: 0x0000021a, entry: 0x00000219, offset: 0x0219
FAT16: entry: 0x0000021a = 538, offset: 0x021a = 538
FAT16: ret: 0x0000021b, entry: 0x0000021a, offset: 0x021a
FAT16: entry: 0x0000021b = 539, offset: 0x021b = 539
FAT16: ret: 0x0000021c, entry: 0x0000021b, offset: 0x021b
FAT16: entry: 0x0000021c = 540, offset: 0x021c = 540
FAT16: ret: 0x0000021d, entry: 0x0000021c, offset: 0x021c
FAT16: entry: 0x0000021d = 541, offset: 0x021d = 541
FAT16: ret: 0x0000021e, entry: 0x0000021d, offset: 0x021d
FAT16: entry: 0x0000021e = 542, offset: 0x021e = 542
FAT16: ret: 0x0000021f, entry: 0x0000021e, offset: 0x021e
FAT16: entry: 0x0000021f = 543, offset: 0x021f = 543
FAT16: ret: 0x00000220, entry: 0x0000021f, offset: 0x021f
FAT16: entry: 0x00000220 = 544, offset: 0x0220 = 544
FAT16: ret: 0x00000221, entry: 0x00000220, offset: 0x0220
FAT16: entry: 0x00000221 = 545, offset: 0x0221 = 545
FAT16: ret: 0x00000222, entry: 0x00000221, offset: 0x0221
FAT16: entry: 0x00000222 = 546, offset: 0x0222 = 546
FAT16: ret: 0x00000223, entry: 0x00000222, offset: 0x0222
FAT16: entry: 0x00000223 = 547, offset: 0x0223 = 547
FAT16: ret: 0x00000224, entry: 0x00000223, offset: 0x0223
FAT16: entry: 0x00000224 = 548, offset: 0x0224 = 548
FAT16: ret: 0x00000225, entry: 0x00000224, offset: 0x0224
FAT16: entry: 0x00000225 = 549, offset: 0x0225 = 549
FAT16: ret: 0x00000226, entry: 0x00000225, offset: 0x0225
FAT16: entry: 0x00000226 = 550, offset: 0x0226 = 550
FAT16: ret: 0x00000227, entry: 0x00000226, offset: 0x0226
FAT16: entry: 0x00000227 = 551, offset: 0x0227 = 551
FAT16: ret: 0x00000228, entry: 0x00000227, offset: 0x0227
FAT16: entry: 0x00000228 = 552, offset: 0x0228 = 552
FAT16: ret: 0x00000229, entry: 0x00000228, offset: 0x0228
FAT16: entry: 0x00000229 = 553, offset: 0x0229 = 553
FAT16: ret: 0x0000022a, entry: 0x00000229, offset: 0x0229
FAT16: entry: 0x0000022a = 554, offset: 0x022a = 554
FAT16: ret: 0x0000022b, entry: 0x0000022a, offset: 0x022a
FAT16: entry: 0x0000022b = 555, offset: 0x022b = 555
FAT16: ret: 0x0000022c, entry: 0x0000022b, offset: 0x022b
FAT16: entry: 0x0000022c = 556, offset: 0x022c = 556
FAT16: ret: 0x0000022d, entry: 0x0000022c, offset: 0x022c
FAT16: entry: 0x0000022d = 557, offset: 0x022d = 557
FAT16: ret: 0x0000022e, entry: 0x0000022d, offset: 0x022d
FAT16: entry: 0x0000022e = 558, offset: 0x022e = 558
FAT16: ret: 0x0000022f, entry: 0x0000022e, offset: 0x022e
FAT16: entry: 0x0000022f = 559, offset: 0x022f = 559
FAT16: ret: 0x00000230, entry: 0x0000022f, offset: 0x022f
FAT16: entry: 0x00000230 = 560, offset: 0x0230 = 560
FAT16: ret: 0x00000231, entry: 0x00000230, offset: 0x0230
FAT16: entry: 0x00000231 = 561, offset: 0x0231 = 561
FAT16: ret: 0x00000232, entry: 0x00000231, offset: 0x0231
FAT16: entry: 0x00000232 = 562, offset: 0x0232 = 562
FAT16: ret: 0x00000233, entry: 0x00000232, offset: 0x0232
FAT16: entry: 0x00000233 = 563, offset: 0x0233 = 563
FAT16: ret: 0x00000234, entry: 0x00000233, offset: 0x0233
FAT16: entry: 0x00000234 = 564, offset: 0x0234 = 564
FAT16: ret: 0x00000235, entry: 0x00000234, offset: 0x0234
FAT16: entry: 0x00000235 = 565, offset: 0x0235 = 565
FAT16: ret: 0x00000236, entry: 0x00000235, offset: 0x0235
FAT16: entry: 0x00000236 = 566, offset: 0x0236 = 566
FAT16: ret: 0x00000237, entry: 0x00000236, offset: 0x0236
FAT16: entry: 0x00000237 = 567, offset: 0x0237 = 567
FAT16: ret: 0x00000238, entry: 0x00000237, offset: 0x0237
FAT16: entry: 0x00000238 = 568, offset: 0x0238 = 568
FAT16: ret: 0x00000239, entry: 0x00000238, offset: 0x0238
FAT16: entry: 0x00000239 = 569, offset: 0x0239 = 569
FAT16: ret: 0x0000023a, entry: 0x00000239, offset: 0x0239
FAT16: entry: 0x0000023a = 570, offset: 0x023a = 570
FAT16: ret: 0x0000023b, entry: 0x0000023a, offset: 0x023a
FAT16: entry: 0x0000023b = 571, offset: 0x023b = 571
FAT16: ret: 0x0000023c, entry: 0x0000023b, offset: 0x023b
FAT16: entry: 0x0000023c = 572, offset: 0x023c = 572
FAT16: ret: 0x0000023d, entry: 0x0000023c, offset: 0x023c
FAT16: entry: 0x0000023d = 573, offset: 0x023d = 573
FAT16: ret: 0x0000023e, entry: 0x0000023d, offset: 0x023d
FAT16: entry: 0x0000023e = 574, offset: 0x023e = 574
FAT16: ret: 0x0000023f, entry: 0x0000023e, offset: 0x023e
FAT16: entry: 0x0000023f = 575, offset: 0x023f = 575
FAT16: ret: 0x00000240, entry: 0x0000023f, offset: 0x023f
FAT16: entry: 0x00000240 = 576, offset: 0x0240 = 576
FAT16: ret: 0x00000241, entry: 0x00000240, offset: 0x0240
FAT16: entry: 0x00000241 = 577, offset: 0x0241 = 577
FAT16: ret: 0x00000242, entry: 0x00000241, offset: 0x0241
FAT16: entry: 0x00000242 = 578, offset: 0x0242 = 578
FAT16: ret: 0x00000243, entry: 0x00000242, offset: 0x0242
FAT16: entry: 0x00000243 = 579, offset: 0x0243 = 579
FAT16: ret: 0x00000244, entry: 0x00000243, offset: 0x0243
FAT16: entry: 0x00000244 = 580, offset: 0x0244 = 580
FAT16: ret: 0x00000245, entry: 0x00000244, offset: 0x0244
FAT16: entry: 0x00000245 = 581, offset: 0x0245 = 581
FAT16: ret: 0x00000246, entry: 0x00000245, offset: 0x0245
FAT16: entry: 0x00000246 = 582, offset: 0x0246 = 582
FAT16: ret: 0x00000247, entry: 0x00000246, offset: 0x0246
FAT16: entry: 0x00000247 = 583, offset: 0x0247 = 583
FAT16: ret: 0x00000248, entry: 0x00000247, offset: 0x0247
FAT16: entry: 0x00000248 = 584, offset: 0x0248 = 584
FAT16: ret: 0x00000249, entry: 0x00000248, offset: 0x0248
FAT16: entry: 0x00000249 = 585, offset: 0x0249 = 585
FAT16: ret: 0x0000024a, entry: 0x00000249, offset: 0x0249
FAT16: entry: 0x0000024a = 586, offset: 0x024a = 586
FAT16: ret: 0x0000024b, entry: 0x0000024a, offset: 0x024a
FAT16: entry: 0x0000024b = 587, offset: 0x024b = 587
FAT16: ret: 0x0000024c, entry: 0x0000024b, offset: 0x024b
FAT16: entry: 0x0000024c = 588, offset: 0x024c = 588
FAT16: ret: 0x0000024d, entry: 0x0000024c, offset: 0x024c
FAT16: entry: 0x0000024d = 589, offset: 0x024d = 589
FAT16: ret: 0x0000024e, entry: 0x0000024d, offset: 0x024d
FAT16: entry: 0x0000024e = 590, offset: 0x024e = 590
FAT16: ret: 0x0000024f, entry: 0x0000024e, offset: 0x024e
FAT16: entry: 0x0000024f = 591, offset: 0x024f = 591
FAT16: ret: 0x00000250, entry: 0x0000024f, offset: 0x024f
FAT16: entry: 0x00000250 = 592, offset: 0x0250 = 592
FAT16: ret: 0x00000251, entry: 0x00000250, offset: 0x0250
FAT16: entry: 0x00000251 = 593, offset: 0x0251 = 593
FAT16: ret: 0x00000252, entry: 0x00000251, offset: 0x0251
FAT16: entry: 0x00000252 = 594, offset: 0x0252 = 594
FAT16: ret: 0x00000253, entry: 0x00000252, offset: 0x0252
FAT16: entry: 0x00000253 = 595, offset: 0x0253 = 595
FAT16: ret: 0x00000254, entry: 0x00000253, offset: 0x0253
FAT16: entry: 0x00000254 = 596, offset: 0x0254 = 596
FAT16: ret: 0x00000255, entry: 0x00000254, offset: 0x0254
FAT16: entry: 0x00000255 = 597, offset: 0x0255 = 597
FAT16: ret: 0x00000256, entry: 0x00000255, offset: 0x0255
FAT16: entry: 0x00000256 = 598, offset: 0x0256 = 598
FAT16: ret: 0x00000257, entry: 0x00000256, offset: 0x0256
FAT16: entry: 0x00000257 = 599, offset: 0x0257 = 599
FAT16: ret: 0x00000258, entry: 0x00000257, offset: 0x0257
FAT16: entry: 0x00000258 = 600, offset: 0x0258 = 600
FAT16: ret: 0x00000259, entry: 0x00000258, offset: 0x0258
FAT16: entry: 0x00000259 = 601, offset: 0x0259 = 601
FAT16: ret: 0x0000025a, entry: 0x00000259, offset: 0x0259
FAT16: entry: 0x0000025a = 602, offset: 0x025a = 602
FAT16: ret: 0x0000025b, entry: 0x0000025a, offset: 0x025a
FAT16: entry: 0x0000025b = 603, offset: 0x025b = 603
FAT16: ret: 0x0000025c, entry: 0x0000025b, offset: 0x025b
FAT16: entry: 0x0000025c = 604, offset: 0x025c = 604
FAT16: ret: 0x0000025d, entry: 0x0000025c, offset: 0x025c
FAT16: entry: 0x0000025d = 605, offset: 0x025d = 605
FAT16: ret: 0x0000025e, entry: 0x0000025d, offset: 0x025d
FAT16: entry: 0x0000025e = 606, offset: 0x025e = 606
FAT16: ret: 0x0000025f, entry: 0x0000025e, offset: 0x025e
FAT16: entry: 0x0000025f = 607, offset: 0x025f = 607
FAT16: ret: 0x00000260, entry: 0x0000025f, offset: 0x025f
FAT16: entry: 0x00000260 = 608, offset: 0x0260 = 608
FAT16: ret: 0x00000261, entry: 0x00000260, offset: 0x0260
FAT16: entry: 0x00000261 = 609, offset: 0x0261 = 609
FAT16: ret: 0x00000262, entry: 0x00000261, offset: 0x0261
FAT16: entry: 0x00000262 = 610, offset: 0x0262 = 610
FAT16: ret: 0x00000263, entry: 0x00000262, offset: 0x0262
FAT16: entry: 0x00000263 = 611, offset: 0x0263 = 611
FAT16: ret: 0x00000264, entry: 0x00000263, offset: 0x0263
FAT16: entry: 0x00000264 = 612, offset: 0x0264 = 612
FAT16: ret: 0x00000265, entry: 0x00000264, offset: 0x0264
FAT16: entry: 0x00000265 = 613, offset: 0x0265 = 613
FAT16: ret: 0x00000266, entry: 0x00000265, offset: 0x0265
FAT16: entry: 0x00000266 = 614, offset: 0x0266 = 614
FAT16: ret: 0x00000267, entry: 0x00000266, offset: 0x0266
FAT16: entry: 0x00000267 = 615, offset: 0x0267 = 615
FAT16: ret: 0x00000268, entry: 0x00000267, offset: 0x0267
FAT16: entry: 0x00000268 = 616, offset: 0x0268 = 616
FAT16: ret: 0x00000269, entry: 0x00000268, offset: 0x0268
FAT16: entry: 0x00000269 = 617, offset: 0x0269 = 617
FAT16: ret: 0x0000026a, entry: 0x00000269, offset: 0x0269
FAT16: entry: 0x0000026a = 618, offset: 0x026a = 618
FAT16: ret: 0x0000026b, entry: 0x0000026a, offset: 0x026a
FAT16: entry: 0x0000026b = 619, offset: 0x026b = 619
FAT16: ret: 0x0000026c, entry: 0x0000026b, offset: 0x026b
FAT16: entry: 0x0000026c = 620, offset: 0x026c = 620
FAT16: ret: 0x0000026d, entry: 0x0000026c, offset: 0x026c
FAT16: entry: 0x0000026d = 621, offset: 0x026d = 621
FAT16: ret: 0x0000026e, entry: 0x0000026d, offset: 0x026d
FAT16: entry: 0x0000026e = 622, offset: 0x026e = 622
FAT16: ret: 0x0000026f, entry: 0x0000026e, offset: 0x026e
FAT16: entry: 0x0000026f = 623, offset: 0x026f = 623
FAT16: ret: 0x00000270, entry: 0x0000026f, offset: 0x026f
FAT16: entry: 0x00000270 = 624, offset: 0x0270 = 624
FAT16: ret: 0x00000271, entry: 0x00000270, offset: 0x0270
FAT16: entry: 0x00000271 = 625, offset: 0x0271 = 625
FAT16: ret: 0x00000272, entry: 0x00000271, offset: 0x0271
FAT16: entry: 0x00000272 = 626, offset: 0x0272 = 626
FAT16: ret: 0x00000273, entry: 0x00000272, offset: 0x0272
FAT16: entry: 0x00000273 = 627, offset: 0x0273 = 627
FAT16: ret: 0x00000274, entry: 0x00000273, offset: 0x0273
FAT16: entry: 0x00000274 = 628, offset: 0x0274 = 628
FAT16: ret: 0x00000275, entry: 0x00000274, offset: 0x0274
FAT16: entry: 0x00000275 = 629, offset: 0x0275 = 629
FAT16: ret: 0x00000276, entry: 0x00000275, offset: 0x0275
FAT16: entry: 0x00000276 = 630, offset: 0x0276 = 630
FAT16: ret: 0x00000277, entry: 0x00000276, offset: 0x0276
FAT16: entry: 0x00000277 = 631, offset: 0x0277 = 631
FAT16: ret: 0x00000278, entry: 0x00000277, offset: 0x0277
FAT16: entry: 0x00000278 = 632, offset: 0x0278 = 632
FAT16: ret: 0x00000279, entry: 0x00000278, offset: 0x0278
FAT16: entry: 0x00000279 = 633, offset: 0x0279 = 633
FAT16: ret: 0x0000027a, entry: 0x00000279, offset: 0x0279
FAT16: entry: 0x0000027a = 634, offset: 0x027a = 634
FAT16: ret: 0x0000027b, entry: 0x0000027a, offset: 0x027a
FAT16: entry: 0x0000027b = 635, offset: 0x027b = 635
FAT16: ret: 0x0000027c, entry: 0x0000027b, offset: 0x027b
FAT16: entry: 0x0000027c = 636, offset: 0x027c = 636
FAT16: ret: 0x0000027d, entry: 0x0000027c, offset: 0x027c
FAT16: entry: 0x0000027d = 637, offset: 0x027d = 637
FAT16: ret: 0x0000027e, entry: 0x0000027d, offset: 0x027d
FAT16: entry: 0x0000027e = 638, offset: 0x027e = 638
FAT16: ret: 0x0000027f, entry: 0x0000027e, offset: 0x027e
FAT16: entry: 0x0000027f = 639, offset: 0x027f = 639
FAT16: ret: 0x00000280, entry: 0x0000027f, offset: 0x027f
FAT16: entry: 0x00000280 = 640, offset: 0x0280 = 640
FAT16: ret: 0x00000281, entry: 0x00000280, offset: 0x0280
FAT16: entry: 0x00000281 = 641, offset: 0x0281 = 641
FAT16: ret: 0x00000282, entry: 0x00000281, offset: 0x0281
FAT16: entry: 0x00000282 = 642, offset: 0x0282 = 642
FAT16: ret: 0x00000283, entry: 0x00000282, offset: 0x0282
FAT16: entry: 0x00000283 = 643, offset: 0x0283 = 643
FAT16: ret: 0x00000284, entry: 0x00000283, offset: 0x0283
FAT16: entry: 0x00000284 = 644, offset: 0x0284 = 644
FAT16: ret: 0x00000285, entry: 0x00000284, offset: 0x0284
FAT16: entry: 0x00000285 = 645, offset: 0x0285 = 645
FAT16: ret: 0x00000286, entry: 0x00000285, offset: 0x0285
FAT16: entry: 0x00000286 = 646, offset: 0x0286 = 646
FAT16: ret: 0x00000287, entry: 0x00000286, offset: 0x0286
FAT16: entry: 0x00000287 = 647, offset: 0x0287 = 647
FAT16: ret: 0x00000288, entry: 0x00000287, offset: 0x0287
FAT16: entry: 0x00000288 = 648, offset: 0x0288 = 648
FAT16: ret: 0x00000289, entry: 0x00000288, offset: 0x0288
FAT16: entry: 0x00000289 = 649, offset: 0x0289 = 649
FAT16: ret: 0x0000028a, entry: 0x00000289, offset: 0x0289
FAT16: entry: 0x0000028a = 650, offset: 0x028a = 650
FAT16: ret: 0x0000028b, entry: 0x0000028a, offset: 0x028a
FAT16: entry: 0x0000028b = 651, offset: 0x028b = 651
FAT16: ret: 0x0000028c, entry: 0x0000028b, offset: 0x028b
FAT16: entry: 0x0000028c = 652, offset: 0x028c = 652
FAT16: ret: 0x0000028d, entry: 0x0000028c, offset: 0x028c
FAT16: entry: 0x0000028d = 653, offset: 0x028d = 653
FAT16: ret: 0x0000028e, entry: 0x0000028d, offset: 0x028d
FAT16: entry: 0x0000028e = 654, offset: 0x028e = 654
FAT16: ret: 0x0000028f, entry: 0x0000028e, offset: 0x028e
FAT16: entry: 0x0000028f = 655, offset: 0x028f = 655
FAT16: ret: 0x00000290, entry: 0x0000028f, offset: 0x028f
FAT16: entry: 0x00000290 = 656, offset: 0x0290 = 656
FAT16: ret: 0x00000291, entry: 0x00000290, offset: 0x0290
FAT16: entry: 0x00000291 = 657, offset: 0x0291 = 657
FAT16: ret: 0x00000292, entry: 0x00000291, offset: 0x0291
FAT16: entry: 0x00000292 = 658, offset: 0x0292 = 658
FAT16: ret: 0x00000293, entry: 0x00000292, offset: 0x0292
FAT16: entry: 0x00000293 = 659, offset: 0x0293 = 659
FAT16: ret: 0x00000294, entry: 0x00000293, offset: 0x0293
FAT16: entry: 0x00000294 = 660, offset: 0x0294 = 660
FAT16: ret: 0x00000295, entry: 0x00000294, offset: 0x0294
FAT16: entry: 0x00000295 = 661, offset: 0x0295 = 661
FAT16: ret: 0x00000296, entry: 0x00000295, offset: 0x0295
FAT16: entry: 0x00000296 = 662, offset: 0x0296 = 662
FAT16: ret: 0x00000297, entry: 0x00000296, offset: 0x0296
FAT16: entry: 0x00000297 = 663, offset: 0x0297 = 663
FAT16: ret: 0x00000298, entry: 0x00000297, offset: 0x0297
FAT16: entry: 0x00000298 = 664, offset: 0x0298 = 664
FAT16: ret: 0x00000299, entry: 0x00000298, offset: 0x0298
FAT16: entry: 0x00000299 = 665, offset: 0x0299 = 665
FAT16: ret: 0x0000029a, entry: 0x00000299, offset: 0x0299
FAT16: entry: 0x0000029a = 666, offset: 0x029a = 666
FAT16: ret: 0x0000029b, entry: 0x0000029a, offset: 0x029a
FAT16: entry: 0x0000029b = 667, offset: 0x029b = 667
FAT16: ret: 0x0000029c, entry: 0x0000029b, offset: 0x029b
FAT16: entry: 0x0000029c = 668, offset: 0x029c = 668
FAT16: ret: 0x0000029d, entry: 0x0000029c, offset: 0x029c
FAT16: entry: 0x0000029d = 669, offset: 0x029d = 669
FAT16: ret: 0x0000029e, entry: 0x0000029d, offset: 0x029d
FAT16: entry: 0x0000029e = 670, offset: 0x029e = 670
FAT16: ret: 0x0000029f, entry: 0x0000029e, offset: 0x029e
FAT16: entry: 0x0000029f = 671, offset: 0x029f = 671
FAT16: ret: 0x000002a0, entry: 0x0000029f, offset: 0x029f
FAT16: entry: 0x000002a0 = 672, offset: 0x02a0 = 672
FAT16: ret: 0x000002a1, entry: 0x000002a0, offset: 0x02a0
FAT16: entry: 0x000002a1 = 673, offset: 0x02a1 = 673
FAT16: ret: 0x000002a2, entry: 0x000002a1, offset: 0x02a1
FAT16: entry: 0x000002a2 = 674, offset: 0x02a2 = 674
FAT16: ret: 0x000002a3, entry: 0x000002a2, offset: 0x02a2
FAT16: entry: 0x000002a3 = 675, offset: 0x02a3 = 675
FAT16: ret: 0x000002a4, entry: 0x000002a3, offset: 0x02a3
FAT16: entry: 0x000002a4 = 676, offset: 0x02a4 = 676
FAT16: ret: 0x000002a5, entry: 0x000002a4, offset: 0x02a4
FAT16: entry: 0x000002a5 = 677, offset: 0x02a5 = 677
FAT16: ret: 0x000002a6, entry: 0x000002a5, offset: 0x02a5
FAT16: entry: 0x000002a6 = 678, offset: 0x02a6 = 678
FAT16: ret: 0x000002a7, entry: 0x000002a6, offset: 0x02a6
FAT16: entry: 0x000002a7 = 679, offset: 0x02a7 = 679
FAT16: ret: 0x000002a8, entry: 0x000002a7, offset: 0x02a7
FAT16: entry: 0x000002a8 = 680, offset: 0x02a8 = 680
FAT16: ret: 0x000002a9, entry: 0x000002a8, offset: 0x02a8
FAT16: entry: 0x000002a9 = 681, offset: 0x02a9 = 681
FAT16: ret: 0x000002aa, entry: 0x000002a9, offset: 0x02a9
FAT16: entry: 0x000002aa = 682, offset: 0x02aa = 682
FAT16: ret: 0x000002ab, entry: 0x000002aa, offset: 0x02aa
FAT16: entry: 0x000002ab = 683, offset: 0x02ab = 683
FAT16: ret: 0x000002ac, entry: 0x000002ab, offset: 0x02ab
FAT16: entry: 0x000002ac = 684, offset: 0x02ac = 684
FAT16: ret: 0x000002ad, entry: 0x000002ac, offset: 0x02ac
FAT16: entry: 0x000002ad = 685, offset: 0x02ad = 685
FAT16: ret: 0x000002ae, entry: 0x000002ad, offset: 0x02ad
FAT16: entry: 0x000002ae = 686, offset: 0x02ae = 686
FAT16: ret: 0x000002af, entry: 0x000002ae, offset: 0x02ae
FAT16: entry: 0x000002af = 687, offset: 0x02af = 687
FAT16: ret: 0x000002b0, entry: 0x000002af, offset: 0x02af
FAT16: entry: 0x000002b0 = 688, offset: 0x02b0 = 688
FAT16: ret: 0x000002b1, entry: 0x000002b0, offset: 0x02b0
FAT16: entry: 0x000002b1 = 689, offset: 0x02b1 = 689
FAT16: ret: 0x000002b2, entry: 0x000002b1, offset: 0x02b1
FAT16: entry: 0x000002b2 = 690, offset: 0x02b2 = 690
FAT16: ret: 0x000002b3, entry: 0x000002b2, offset: 0x02b2
FAT16: entry: 0x000002b3 = 691, offset: 0x02b3 = 691
FAT16: ret: 0x000002b4, entry: 0x000002b3, offset: 0x02b3
FAT16: entry: 0x000002b4 = 692, offset: 0x02b4 = 692
FAT16: ret: 0x000002b5, entry: 0x000002b4, offset: 0x02b4
FAT16: entry: 0x000002b5 = 693, offset: 0x02b5 = 693
FAT16: ret: 0x000002b6, entry: 0x000002b5, offset: 0x02b5
FAT16: entry: 0x000002b6 = 694, offset: 0x02b6 = 694
FAT16: ret: 0x000002b7, entry: 0x000002b6, offset: 0x02b6
FAT16: entry: 0x000002b7 = 695, offset: 0x02b7 = 695
FAT16: ret: 0x000002b8, entry: 0x000002b7, offset: 0x02b7
FAT16: entry: 0x000002b8 = 696, offset: 0x02b8 = 696
FAT16: ret: 0x000002b9, entry: 0x000002b8, offset: 0x02b8
FAT16: entry: 0x000002b9 = 697, offset: 0x02b9 = 697
FAT16: ret: 0x000002ba, entry: 0x000002b9, offset: 0x02b9
FAT16: entry: 0x000002ba = 698, offset: 0x02ba = 698
FAT16: ret: 0x000002bb, entry: 0x000002ba, offset: 0x02ba
FAT16: entry: 0x000002bb = 699, offset: 0x02bb = 699
FAT16: ret: 0x000002bc, entry: 0x000002bb, offset: 0x02bb
FAT16: entry: 0x000002bc = 700, offset: 0x02bc = 700
FAT16: ret: 0x000002bd, entry: 0x000002bc, offset: 0x02bc
FAT16: entry: 0x000002bd = 701, offset: 0x02bd = 701
FAT16: ret: 0x000002be, entry: 0x000002bd, offset: 0x02bd
FAT16: entry: 0x000002be = 702, offset: 0x02be = 702
FAT16: ret: 0x000002bf, entry: 0x000002be, offset: 0x02be
FAT16: entry: 0x000002bf = 703, offset: 0x02bf = 703
FAT16: ret: 0x000002c0, entry: 0x000002bf, offset: 0x02bf
FAT16: entry: 0x000002c0 = 704, offset: 0x02c0 = 704
FAT16: ret: 0x000002c1, entry: 0x000002c0, offset: 0x02c0
FAT16: entry: 0x000002c1 = 705, offset: 0x02c1 = 705
FAT16: ret: 0x000002c2, entry: 0x000002c1, offset: 0x02c1
FAT16: entry: 0x000002c2 = 706, offset: 0x02c2 = 706
FAT16: ret: 0x000002c3, entry: 0x000002c2, offset: 0x02c2
FAT16: entry: 0x000002c3 = 707, offset: 0x02c3 = 707
FAT16: ret: 0x000002c4, entry: 0x000002c3, offset: 0x02c3
FAT16: entry: 0x000002c4 = 708, offset: 0x02c4 = 708
FAT16: ret: 0x000002c5, entry: 0x000002c4, offset: 0x02c4
FAT16: entry: 0x000002c5 = 709, offset: 0x02c5 = 709
FAT16: ret: 0x000002c6, entry: 0x000002c5, offset: 0x02c5
FAT16: entry: 0x000002c6 = 710, offset: 0x02c6 = 710
FAT16: ret: 0x000002c7, entry: 0x000002c6, offset: 0x02c6
FAT16: entry: 0x000002c7 = 711, offset: 0x02c7 = 711
FAT16: ret: 0x000002c8, entry: 0x000002c7, offset: 0x02c7
FAT16: entry: 0x000002c8 = 712, offset: 0x02c8 = 712
FAT16: ret: 0x000002c9, entry: 0x000002c8, offset: 0x02c8
FAT16: entry: 0x000002c9 = 713, offset: 0x02c9 = 713
FAT16: ret: 0x000002ca, entry: 0x000002c9, offset: 0x02c9
FAT16: entry: 0x000002ca = 714, offset: 0x02ca = 714
FAT16: ret: 0x000002cb, entry: 0x000002ca, offset: 0x02ca
FAT16: entry: 0x000002cb = 715, offset: 0x02cb = 715
FAT16: ret: 0x000002cc, entry: 0x000002cb, offset: 0x02cb
FAT16: entry: 0x000002cc = 716, offset: 0x02cc = 716
FAT16: ret: 0x000002cd, entry: 0x000002cc, offset: 0x02cc
FAT16: entry: 0x000002cd = 717, offset: 0x02cd = 717
FAT16: ret: 0x000002ce, entry: 0x000002cd, offset: 0x02cd
FAT16: entry: 0x000002ce = 718, offset: 0x02ce = 718
FAT16: ret: 0x000002ef, entry: 0x000002ce, offset: 0x02ce
FAT16: entry: 0x000002ef = 751, offset: 0x02ef = 751
FAT16: ret: 0x000002f0, entry: 0x000002ef, offset: 0x02ef
FAT16: entry: 0x000002f0 = 752, offset: 0x02f0 = 752
FAT16: ret: 0x000002f1, entry: 0x000002f0, offset: 0x02f0
FAT16: entry: 0x000002f1 = 753, offset: 0x02f1 = 753
FAT16: ret: 0x000002f2, entry: 0x000002f1, offset: 0x02f1
FAT16: entry: 0x000002f2 = 754, offset: 0x02f2 = 754
FAT16: ret: 0x000002f3, entry: 0x000002f2, offset: 0x02f2
FAT16: entry: 0x000002f3 = 755, offset: 0x02f3 = 755
FAT16: ret: 0x000002f4, entry: 0x000002f3, offset: 0x02f3
FAT16: entry: 0x000002f4 = 756, offset: 0x02f4 = 756
FAT16: ret: 0x000002f5, entry: 0x000002f4, offset: 0x02f4
FAT16: entry: 0x000002f5 = 757, offset: 0x02f5 = 757
FAT16: ret: 0x000002f6, entry: 0x000002f5, offset: 0x02f5
FAT16: entry: 0x000002f6 = 758, offset: 0x02f6 = 758
FAT16: ret: 0x000002f7, entry: 0x000002f6, offset: 0x02f6
FAT16: entry: 0x000002f7 = 759, offset: 0x02f7 = 759
FAT16: ret: 0x000002f8, entry: 0x000002f7, offset: 0x02f7
FAT16: entry: 0x000002f8 = 760, offset: 0x02f8 = 760
FAT16: ret: 0x000002f9, entry: 0x000002f8, offset: 0x02f8
FAT16: entry: 0x000002f9 = 761, offset: 0x02f9 = 761
FAT16: ret: 0x000002fa, entry: 0x000002f9, offset: 0x02f9
FAT16: entry: 0x000002fa = 762, offset: 0x02fa = 762
FAT16: ret: 0x000002fb, entry: 0x000002fa, offset: 0x02fa
FAT16: entry: 0x000002fb = 763, offset: 0x02fb = 763
FAT16: ret: 0x000002fc, entry: 0x000002fb, offset: 0x02fb
FAT16: entry: 0x000002fc = 764, offset: 0x02fc = 764
FAT16: ret: 0x000002fd, entry: 0x000002fc, offset: 0x02fc
FAT16: entry: 0x000002fd = 765, offset: 0x02fd = 765
FAT16: ret: 0x000002fe, entry: 0x000002fd, offset: 0x02fd
FAT16: entry: 0x000002fe = 766, offset: 0x02fe = 766
FAT16: ret: 0x000002ff, entry: 0x000002fe, offset: 0x02fe
FAT16: entry: 0x000002ff = 767, offset: 0x02ff = 767
FAT16: ret: 0x00000300, entry: 0x000002ff, offset: 0x02ff
FAT16: entry: 0x00000300 = 768, offset: 0x0300 = 768
FAT16: ret: 0x00000301, entry: 0x00000300, offset: 0x0300
FAT16: entry: 0x00000301 = 769, offset: 0x0301 = 769
FAT16: ret: 0x00000302, entry: 0x00000301, offset: 0x0301
FAT16: entry: 0x00000302 = 770, offset: 0x0302 = 770
FAT16: ret: 0x00000303, entry: 0x00000302, offset: 0x0302
FAT16: entry: 0x00000303 = 771, offset: 0x0303 = 771
FAT16: ret: 0x00000304, entry: 0x00000303, offset: 0x0303
FAT16: entry: 0x00000304 = 772, offset: 0x0304 = 772
FAT16: ret: 0x00000305, entry: 0x00000304, offset: 0x0304
FAT16: entry: 0x00000305 = 773, offset: 0x0305 = 773
FAT16: ret: 0x00000306, entry: 0x00000305, offset: 0x0305
FAT16: entry: 0x00000306 = 774, offset: 0x0306 = 774
FAT16: ret: 0x00000307, entry: 0x00000306, offset: 0x0306
FAT16: entry: 0x00000307 = 775, offset: 0x0307 = 775
FAT16: ret: 0x00000308, entry: 0x00000307, offset: 0x0307
FAT16: entry: 0x00000308 = 776, offset: 0x0308 = 776
FAT16: ret: 0x00000309, entry: 0x00000308, offset: 0x0308
FAT16: entry: 0x00000309 = 777, offset: 0x0309 = 777
FAT16: ret: 0x0000030a, entry: 0x00000309, offset: 0x0309
FAT16: entry: 0x0000030a = 778, offset: 0x030a = 778
FAT16: ret: 0x0000030b, entry: 0x0000030a, offset: 0x030a
FAT16: entry: 0x0000030b = 779, offset: 0x030b = 779
FAT16: ret: 0x0000030c, entry: 0x0000030b, offset: 0x030b
FAT16: entry: 0x0000030c = 780, offset: 0x030c = 780
FAT16: ret: 0x0000030d, entry: 0x0000030c, offset: 0x030c
FAT16: entry: 0x0000030d = 781, offset: 0x030d = 781
FAT16: ret: 0x0000030e, entry: 0x0000030d, offset: 0x030d
FAT16: entry: 0x0000030e = 782, offset: 0x030e = 782
FAT16: ret: 0x0000030f, entry: 0x0000030e, offset: 0x030e
FAT16: entry: 0x0000030f = 783, offset: 0x030f = 783
FAT16: ret: 0x00000310, entry: 0x0000030f, offset: 0x030f
FAT16: entry: 0x00000310 = 784, offset: 0x0310 = 784
FAT16: ret: 0x00000311, entry: 0x00000310, offset: 0x0310
FAT16: entry: 0x00000311 = 785, offset: 0x0311 = 785
FAT16: ret: 0x00000312, entry: 0x00000311, offset: 0x0311
FAT16: entry: 0x00000312 = 786, offset: 0x0312 = 786
FAT16: ret: 0x00000313, entry: 0x00000312, offset: 0x0312
FAT16: entry: 0x00000313 = 787, offset: 0x0313 = 787
FAT16: ret: 0x00000314, entry: 0x00000313, offset: 0x0313
FAT16: entry: 0x00000314 = 788, offset: 0x0314 = 788
FAT16: ret: 0x00000315, entry: 0x00000314, offset: 0x0314
FAT16: entry: 0x00000315 = 789, offset: 0x0315 = 789
FAT16: ret: 0x00000316, entry: 0x00000315, offset: 0x0315
FAT16: entry: 0x00000316 = 790, offset: 0x0316 = 790
FAT16: ret: 0x00000317, entry: 0x00000316, offset: 0x0316
FAT16: entry: 0x00000317 = 791, offset: 0x0317 = 791
FAT16: ret: 0x00000318, entry: 0x00000317, offset: 0x0317
FAT16: entry: 0x00000318 = 792, offset: 0x0318 = 792
FAT16: ret: 0x00000319, entry: 0x00000318, offset: 0x0318
FAT16: entry: 0x00000319 = 793, offset: 0x0319 = 793
FAT16: ret: 0x0000031a, entry: 0x00000319, offset: 0x0319
FAT16: entry: 0x0000031a = 794, offset: 0x031a = 794
FAT16: ret: 0x0000031b, entry: 0x0000031a, offset: 0x031a
FAT16: entry: 0x0000031b = 795, offset: 0x031b = 795
FAT16: ret: 0x0000031c, entry: 0x0000031b, offset: 0x031b
FAT16: entry: 0x0000031c = 796, offset: 0x031c = 796
FAT16: ret: 0x0000031d, entry: 0x0000031c, offset: 0x031c
FAT16: entry: 0x0000031d = 797, offset: 0x031d = 797
FAT16: ret: 0x0000031e, entry: 0x0000031d, offset: 0x031d
FAT16: entry: 0x0000031e = 798, offset: 0x031e = 798
FAT16: ret: 0x0000031f, entry: 0x0000031e, offset: 0x031e
FAT16: entry: 0x0000031f = 799, offset: 0x031f = 799
FAT16: ret: 0x00000320, entry: 0x0000031f, offset: 0x031f
FAT16: entry: 0x00000320 = 800, offset: 0x0320 = 800
FAT16: ret: 0x00000321, entry: 0x00000320, offset: 0x0320
FAT16: entry: 0x00000321 = 801, offset: 0x0321 = 801
FAT16: ret: 0x00000322, entry: 0x00000321, offset: 0x0321
FAT16: entry: 0x00000322 = 802, offset: 0x0322 = 802
FAT16: ret: 0x00000323, entry: 0x00000322, offset: 0x0322
FAT16: entry: 0x00000323 = 803, offset: 0x0323 = 803
FAT16: ret: 0x00000324, entry: 0x00000323, offset: 0x0323
FAT16: entry: 0x00000324 = 804, offset: 0x0324 = 804
FAT16: ret: 0x00000325, entry: 0x00000324, offset: 0x0324
FAT16: entry: 0x00000325 = 805, offset: 0x0325 = 805
FAT16: ret: 0x00000326, entry: 0x00000325, offset: 0x0325
FAT16: entry: 0x00000326 = 806, offset: 0x0326 = 806
FAT16: ret: 0x00000327, entry: 0x00000326, offset: 0x0326
FAT16: entry: 0x00000327 = 807, offset: 0x0327 = 807
FAT16: ret: 0x00000328, entry: 0x00000327, offset: 0x0327
FAT16: entry: 0x00000328 = 808, offset: 0x0328 = 808
FAT16: ret: 0x00000329, entry: 0x00000328, offset: 0x0328
FAT16: entry: 0x00000329 = 809, offset: 0x0329 = 809
FAT16: ret: 0x0000032a, entry: 0x00000329, offset: 0x0329
FAT16: entry: 0x0000032a = 810, offset: 0x032a = 810
FAT16: ret: 0x0000032b, entry: 0x0000032a, offset: 0x032a
FAT16: entry: 0x0000032b = 811, offset: 0x032b = 811
FAT16: ret: 0x0000032c, entry: 0x0000032b, offset: 0x032b
FAT16: entry: 0x0000032c = 812, offset: 0x032c = 812
FAT16: ret: 0x0000032d, entry: 0x0000032c, offset: 0x032c
FAT16: entry: 0x0000032d = 813, offset: 0x032d = 813
FAT16: ret: 0x0000032e, entry: 0x0000032d, offset: 0x032d
FAT16: entry: 0x0000032e = 814, offset: 0x032e = 814
FAT16: ret: 0x0000032f, entry: 0x0000032e, offset: 0x032e
FAT16: entry: 0x0000032f = 815, offset: 0x032f = 815
FAT16: ret: 0x00000330, entry: 0x0000032f, offset: 0x032f
FAT16: entry: 0x00000330 = 816, offset: 0x0330 = 816
FAT16: ret: 0x00000331, entry: 0x00000330, offset: 0x0330
FAT16: entry: 0x00000331 = 817, offset: 0x0331 = 817
FAT16: ret: 0x00000332, entry: 0x00000331, offset: 0x0331
FAT16: entry: 0x00000332 = 818, offset: 0x0332 = 818
FAT16: ret: 0x00000333, entry: 0x00000332, offset: 0x0332
FAT16: entry: 0x00000333 = 819, offset: 0x0333 = 819
FAT16: ret: 0x00000334, entry: 0x00000333, offset: 0x0333
FAT16: entry: 0x00000334 = 820, offset: 0x0334 = 820
FAT16: ret: 0x00000335, entry: 0x00000334, offset: 0x0334
FAT16: entry: 0x00000335 = 821, offset: 0x0335 = 821
FAT16: ret: 0x00000336, entry: 0x00000335, offset: 0x0335
FAT16: entry: 0x00000336 = 822, offset: 0x0336 = 822
FAT16: ret: 0x00000337, entry: 0x00000336, offset: 0x0336
FAT16: entry: 0x00000337 = 823, offset: 0x0337 = 823
FAT16: ret: 0x00000338, entry: 0x00000337, offset: 0x0337
FAT16: entry: 0x00000338 = 824, offset: 0x0338 = 824
FAT16: ret: 0x00000339, entry: 0x00000338, offset: 0x0338
FAT16: entry: 0x00000339 = 825, offset: 0x0339 = 825
FAT16: ret: 0x0000033a, entry: 0x00000339, offset: 0x0339
FAT16: entry: 0x0000033a = 826, offset: 0x033a = 826
FAT16: ret: 0x0000033b, entry: 0x0000033a, offset: 0x033a
FAT16: entry: 0x0000033b = 827, offset: 0x033b = 827
FAT16: ret: 0x0000033c, entry: 0x0000033b, offset: 0x033b
FAT16: entry: 0x0000033c = 828, offset: 0x033c = 828
FAT16: ret: 0x0000033d, entry: 0x0000033c, offset: 0x033c
FAT16: entry: 0x0000033d = 829, offset: 0x033d = 829
FAT16: ret: 0x0000033e, entry: 0x0000033d, offset: 0x033d
FAT16: entry: 0x0000033e = 830, offset: 0x033e = 830
FAT16: ret: 0x0000033f, entry: 0x0000033e, offset: 0x033e
FAT16: entry: 0x0000033f = 831, offset: 0x033f = 831
FAT16: ret: 0x00000340, entry: 0x0000033f, offset: 0x033f
FAT16: entry: 0x00000340 = 832, offset: 0x0340 = 832
FAT16: ret: 0x00000341, entry: 0x00000340, offset: 0x0340
FAT16: entry: 0x00000341 = 833, offset: 0x0341 = 833
FAT16: ret: 0x00000342, entry: 0x00000341, offset: 0x0341
FAT16: entry: 0x00000342 = 834, offset: 0x0342 = 834
FAT16: ret: 0x00000343, entry: 0x00000342, offset: 0x0342
FAT16: entry: 0x00000343 = 835, offset: 0x0343 = 835
FAT16: ret: 0x00000344, entry: 0x00000343, offset: 0x0343
FAT16: entry: 0x00000344 = 836, offset: 0x0344 = 836
FAT16: ret: 0x00000345, entry: 0x00000344, offset: 0x0344
FAT16: entry: 0x00000345 = 837, offset: 0x0345 = 837
FAT16: ret: 0x00000346, entry: 0x00000345, offset: 0x0345
FAT16: entry: 0x00000346 = 838, offset: 0x0346 = 838
FAT16: ret: 0x00000347, entry: 0x00000346, offset: 0x0346
FAT16: entry: 0x00000347 = 839, offset: 0x0347 = 839
FAT16: ret: 0x00000348, entry: 0x00000347, offset: 0x0347
FAT16: entry: 0x00000348 = 840, offset: 0x0348 = 840
FAT16: ret: 0x00000349, entry: 0x00000348, offset: 0x0348
FAT16: entry: 0x00000349 = 841, offset: 0x0349 = 841
FAT16: ret: 0x0000034a, entry: 0x00000349, offset: 0x0349
FAT16: entry: 0x0000034a = 842, offset: 0x034a = 842
FAT16: ret: 0x0000034b, entry: 0x0000034a, offset: 0x034a
FAT16: entry: 0x0000034b = 843, offset: 0x034b = 843
FAT16: ret: 0x0000034c, entry: 0x0000034b, offset: 0x034b
FAT16: entry: 0x0000034c = 844, offset: 0x034c = 844
FAT16: ret: 0x0000034d, entry: 0x0000034c, offset: 0x034c
FAT16: entry: 0x0000034d = 845, offset: 0x034d = 845
FAT16: ret: 0x0000034e, entry: 0x0000034d, offset: 0x034d
FAT16: entry: 0x0000034e = 846, offset: 0x034e = 846
FAT16: ret: 0x0000034f, entry: 0x0000034e, offset: 0x034e
FAT16: entry: 0x0000034f = 847, offset: 0x034f = 847
FAT16: ret: 0x00000350, entry: 0x0000034f, offset: 0x034f
FAT16: entry: 0x00000350 = 848, offset: 0x0350 = 848
FAT16: ret: 0x00000351, entry: 0x00000350, offset: 0x0350
FAT16: entry: 0x00000351 = 849, offset: 0x0351 = 849
FAT16: ret: 0x00000352, entry: 0x00000351, offset: 0x0351
FAT16: entry: 0x00000352 = 850, offset: 0x0352 = 850
FAT16: ret: 0x00000353, entry: 0x00000352, offset: 0x0352
FAT16: entry: 0x00000353 = 851, offset: 0x0353 = 851
FAT16: ret: 0x00000354, entry: 0x00000353, offset: 0x0353
FAT16: entry: 0x00000354 = 852, offset: 0x0354 = 852
FAT16: ret: 0x00000355, entry: 0x00000354, offset: 0x0354
FAT16: entry: 0x00000355 = 853, offset: 0x0355 = 853
FAT16: ret: 0x00000356, entry: 0x00000355, offset: 0x0355
FAT16: entry: 0x00000356 = 854, offset: 0x0356 = 854
FAT16: ret: 0x00000357, entry: 0x00000356, offset: 0x0356
FAT16: entry: 0x00000357 = 855, offset: 0x0357 = 855
FAT16: ret: 0x00000358, entry: 0x00000357, offset: 0x0357
FAT16: entry: 0x00000358 = 856, offset: 0x0358 = 856
FAT16: ret: 0x00000359, entry: 0x00000358, offset: 0x0358
FAT16: entry: 0x00000359 = 857, offset: 0x0359 = 857
FAT16: ret: 0x0000035a, entry: 0x00000359, offset: 0x0359
FAT16: entry: 0x0000035a = 858, offset: 0x035a = 858
FAT16: ret: 0x0000035b, entry: 0x0000035a, offset: 0x035a
FAT16: entry: 0x0000035b = 859, offset: 0x035b = 859
FAT16: ret: 0x0000035c, entry: 0x0000035b, offset: 0x035b
FAT16: entry: 0x0000035c = 860, offset: 0x035c = 860
FAT16: ret: 0x0000035d, entry: 0x0000035c, offset: 0x035c
FAT16: entry: 0x0000035d = 861, offset: 0x035d = 861
FAT16: ret: 0x0000035e, entry: 0x0000035d, offset: 0x035d
FAT16: entry: 0x0000035e = 862, offset: 0x035e = 862
FAT16: ret: 0x0000035f, entry: 0x0000035e, offset: 0x035e
FAT16: entry: 0x0000035f = 863, offset: 0x035f = 863
FAT16: ret: 0x00000360, entry: 0x0000035f, offset: 0x035f
FAT16: entry: 0x00000360 = 864, offset: 0x0360 = 864
FAT16: ret: 0x00000361, entry: 0x00000360, offset: 0x0360
FAT16: entry: 0x00000361 = 865, offset: 0x0361 = 865
FAT16: ret: 0x00000362, entry: 0x00000361, offset: 0x0361
FAT16: entry: 0x00000362 = 866, offset: 0x0362 = 866
FAT16: ret: 0x00000363, entry: 0x00000362, offset: 0x0362
FAT16: entry: 0x00000363 = 867, offset: 0x0363 = 867
FAT16: ret: 0x00000364, entry: 0x00000363, offset: 0x0363
FAT16: entry: 0x00000364 = 868, offset: 0x0364 = 868
FAT16: ret: 0x00000365, entry: 0x00000364, offset: 0x0364
FAT16: entry: 0x00000365 = 869, offset: 0x0365 = 869
FAT16: ret: 0x00000366, entry: 0x00000365, offset: 0x0365
FAT16: entry: 0x00000366 = 870, offset: 0x0366 = 870
FAT16: ret: 0x00000367, entry: 0x00000366, offset: 0x0366
FAT16: entry: 0x00000367 = 871, offset: 0x0367 = 871
FAT16: ret: 0x00000368, entry: 0x00000367, offset: 0x0367
FAT16: entry: 0x00000368 = 872, offset: 0x0368 = 872
FAT16: ret: 0x00000369, entry: 0x00000368, offset: 0x0368
FAT16: entry: 0x00000369 = 873, offset: 0x0369 = 873
FAT16: ret: 0x0000036a, entry: 0x00000369, offset: 0x0369
FAT16: entry: 0x0000036a = 874, offset: 0x036a = 874
FAT16: ret: 0x0000036b, entry: 0x0000036a, offset: 0x036a
FAT16: entry: 0x0000036b = 875, offset: 0x036b = 875
FAT16: ret: 0x0000036c, entry: 0x0000036b, offset: 0x036b
FAT16: entry: 0x0000036c = 876, offset: 0x036c = 876
FAT16: ret: 0x0000036d, entry: 0x0000036c, offset: 0x036c
FAT16: entry: 0x0000036d = 877, offset: 0x036d = 877
FAT16: ret: 0x0000036e, entry: 0x0000036d, offset: 0x036d
FAT16: entry: 0x0000036e = 878, offset: 0x036e = 878
FAT16: ret: 0x0000036f, entry: 0x0000036e, offset: 0x036e
FAT16: entry: 0x0000036f = 879, offset: 0x036f = 879
FAT16: ret: 0x00000370, entry: 0x0000036f, offset: 0x036f
FAT16: entry: 0x00000370 = 880, offset: 0x0370 = 880
FAT16: ret: 0x00000371, entry: 0x00000370, offset: 0x0370
FAT16: entry: 0x00000371 = 881, offset: 0x0371 = 881
FAT16: ret: 0x00000372, entry: 0x00000371, offset: 0x0371
FAT16: entry: 0x00000372 = 882, offset: 0x0372 = 882
FAT16: ret: 0x00000373, entry: 0x00000372, offset: 0x0372
FAT16: entry: 0x00000373 = 883, offset: 0x0373 = 883
FAT16: ret: 0x00000374, entry: 0x00000373, offset: 0x0373
FAT16: entry: 0x00000374 = 884, offset: 0x0374 = 884
FAT16: ret: 0x00000375, entry: 0x00000374, offset: 0x0374
FAT16: entry: 0x00000375 = 885, offset: 0x0375 = 885
FAT16: ret: 0x00000376, entry: 0x00000375, offset: 0x0375
FAT16: entry: 0x00000376 = 886, offset: 0x0376 = 886
FAT16: ret: 0x00000377, entry: 0x00000376, offset: 0x0376
FAT16: entry: 0x00000377 = 887, offset: 0x0377 = 887
FAT16: ret: 0x00000378, entry: 0x00000377, offset: 0x0377
FAT16: entry: 0x00000378 = 888, offset: 0x0378 = 888
FAT16: ret: 0x00000379, entry: 0x00000378, offset: 0x0378
FAT16: entry: 0x00000379 = 889, offset: 0x0379 = 889
FAT16: ret: 0x0000037a, entry: 0x00000379, offset: 0x0379
FAT16: entry: 0x0000037a = 890, offset: 0x037a = 890
FAT16: ret: 0x0000037b, entry: 0x0000037a, offset: 0x037a
FAT16: entry: 0x0000037b = 891, offset: 0x037b = 891
FAT16: ret: 0x0000037c, entry: 0x0000037b, offset: 0x037b
FAT16: entry: 0x0000037c = 892, offset: 0x037c = 892
FAT16: ret: 0x0000037d, entry: 0x0000037c, offset: 0x037c
FAT16: entry: 0x0000037d = 893, offset: 0x037d = 893
FAT16: ret: 0x0000037e, entry: 0x0000037d, offset: 0x037d
FAT16: entry: 0x0000037e = 894, offset: 0x037e = 894
FAT16: ret: 0x0000037f, entry: 0x0000037e, offset: 0x037e
FAT16: entry: 0x0000037f = 895, offset: 0x037f = 895
FAT16: ret: 0x00000380, entry: 0x0000037f, offset: 0x037f
FAT16: entry: 0x00000380 = 896, offset: 0x0380 = 896
FAT16: ret: 0x00000381, entry: 0x00000380, offset: 0x0380
FAT16: entry: 0x00000381 = 897, offset: 0x0381 = 897
FAT16: ret: 0x00000382, entry: 0x00000381, offset: 0x0381
FAT16: entry: 0x00000382 = 898, offset: 0x0382 = 898
FAT16: ret: 0x00000383, entry: 0x00000382, offset: 0x0382
FAT16: entry: 0x00000383 = 899, offset: 0x0383 = 899
FAT16: ret: 0x00000384, entry: 0x00000383, offset: 0x0383
FAT16: entry: 0x00000384 = 900, offset: 0x0384 = 900
FAT16: ret: 0x00000385, entry: 0x00000384, offset: 0x0384
FAT16: entry: 0x00000385 = 901, offset: 0x0385 = 901
FAT16: ret: 0x00000386, entry: 0x00000385, offset: 0x0385
FAT16: entry: 0x00000386 = 902, offset: 0x0386 = 902
FAT16: ret: 0x00000387, entry: 0x00000386, offset: 0x0386
FAT16: entry: 0x00000387 = 903, offset: 0x0387 = 903
FAT16: ret: 0x00000388, entry: 0x00000387, offset: 0x0387
FAT16: entry: 0x00000388 = 904, offset: 0x0388 = 904
FAT16: ret: 0x00000389, entry: 0x00000388, offset: 0x0388
FAT16: entry: 0x00000389 = 905, offset: 0x0389 = 905
FAT16: ret: 0x0000038a, entry: 0x00000389, offset: 0x0389
FAT16: entry: 0x0000038a = 906, offset: 0x038a = 906
FAT16: ret: 0x0000038b, entry: 0x0000038a, offset: 0x038a
FAT16: entry: 0x0000038b = 907, offset: 0x038b = 907
FAT16: ret: 0x0000038c, entry: 0x0000038b, offset: 0x038b
FAT16: entry: 0x0000038c = 908, offset: 0x038c = 908
FAT16: ret: 0x0000038d, entry: 0x0000038c, offset: 0x038c
FAT16: entry: 0x0000038d = 909, offset: 0x038d = 909
FAT16: ret: 0x0000038e, entry: 0x0000038d, offset: 0x038d
FAT16: entry: 0x0000038e = 910, offset: 0x038e = 910
FAT16: ret: 0x0000038f, entry: 0x0000038e, offset: 0x038e
FAT16: entry: 0x0000038f = 911, offset: 0x038f = 911
FAT16: ret: 0x00000390, entry: 0x0000038f, offset: 0x038f
FAT16: entry: 0x00000390 = 912, offset: 0x0390 = 912
FAT16: ret: 0x00000391, entry: 0x00000390, offset: 0x0390
FAT16: entry: 0x00000391 = 913, offset: 0x0391 = 913
FAT16: ret: 0x00000392, entry: 0x00000391, offset: 0x0391
FAT16: entry: 0x00000392 = 914, offset: 0x0392 = 914
FAT16: ret: 0x00000393, entry: 0x00000392, offset: 0x0392
FAT16: entry: 0x00000393 = 915, offset: 0x0393 = 915
FAT16: ret: 0x00000394, entry: 0x00000393, offset: 0x0393
FAT16: entry: 0x00000394 = 916, offset: 0x0394 = 916
FAT16: ret: 0x00000395, entry: 0x00000394, offset: 0x0394
FAT16: entry: 0x00000395 = 917, offset: 0x0395 = 917
FAT16: ret: 0x00000396, entry: 0x00000395, offset: 0x0395
FAT16: entry: 0x00000396 = 918, offset: 0x0396 = 918
FAT16: ret: 0x00000397, entry: 0x00000396, offset: 0x0396
FAT16: entry: 0x00000397 = 919, offset: 0x0397 = 919
FAT16: ret: 0x00000398, entry: 0x00000397, offset: 0x0397
FAT16: entry: 0x00000398 = 920, offset: 0x0398 = 920
FAT16: ret: 0x00000399, entry: 0x00000398, offset: 0x0398
FAT16: entry: 0x00000399 = 921, offset: 0x0399 = 921
FAT16: ret: 0x0000039a, entry: 0x00000399, offset: 0x0399
FAT16: entry: 0x0000039a = 922, offset: 0x039a = 922
FAT16: ret: 0x0000039b, entry: 0x0000039a, offset: 0x039a
FAT16: entry: 0x0000039b = 923, offset: 0x039b = 923
FAT16: ret: 0x0000039c, entry: 0x0000039b, offset: 0x039b
FAT16: entry: 0x0000039c = 924, offset: 0x039c = 924
FAT16: ret: 0x0000039d, entry: 0x0000039c, offset: 0x039c
FAT16: entry: 0x0000039d = 925, offset: 0x039d = 925
FAT16: ret: 0x0000039e, entry: 0x0000039d, offset: 0x039d
FAT16: entry: 0x0000039e = 926, offset: 0x039e = 926
FAT16: ret: 0x0000039f, entry: 0x0000039e, offset: 0x039e
FAT16: entry: 0x0000039f = 927, offset: 0x039f = 927
FAT16: ret: 0x000003a0, entry: 0x0000039f, offset: 0x039f
FAT16: entry: 0x000003a0 = 928, offset: 0x03a0 = 928
FAT16: ret: 0x000003a1, entry: 0x000003a0, offset: 0x03a0
FAT16: entry: 0x000003a1 = 929, offset: 0x03a1 = 929
FAT16: ret: 0x000003a2, entry: 0x000003a1, offset: 0x03a1
FAT16: entry: 0x000003a2 = 930, offset: 0x03a2 = 930
FAT16: ret: 0x000003a3, entry: 0x000003a2, offset: 0x03a2
FAT16: entry: 0x000003a3 = 931, offset: 0x03a3 = 931
FAT16: ret: 0x000003a4, entry: 0x000003a3, offset: 0x03a3
FAT16: entry: 0x000003a4 = 932, offset: 0x03a4 = 932
FAT16: ret: 0x000003a5, entry: 0x000003a4, offset: 0x03a4
FAT16: entry: 0x000003a5 = 933, offset: 0x03a5 = 933
FAT16: ret: 0x000003a6, entry: 0x000003a5, offset: 0x03a5
FAT16: entry: 0x000003a6 = 934, offset: 0x03a6 = 934
FAT16: ret: 0x000003a7, entry: 0x000003a6, offset: 0x03a6
FAT16: entry: 0x000003a7 = 935, offset: 0x03a7 = 935
FAT16: ret: 0x000003a8, entry: 0x000003a7, offset: 0x03a7
FAT16: entry: 0x000003a8 = 936, offset: 0x03a8 = 936
FAT16: ret: 0x000003a9, entry: 0x000003a8, offset: 0x03a8
FAT16: entry: 0x000003a9 = 937, offset: 0x03a9 = 937
FAT16: ret: 0x000003aa, entry: 0x000003a9, offset: 0x03a9
FAT16: entry: 0x000003aa = 938, offset: 0x03aa = 938
FAT16: ret: 0x000003ab, entry: 0x000003aa, offset: 0x03aa
FAT16: entry: 0x000003ab = 939, offset: 0x03ab = 939
FAT16: ret: 0x000003ac, entry: 0x000003ab, offset: 0x03ab
FAT16: entry: 0x000003ac = 940, offset: 0x03ac = 940
FAT16: ret: 0x000003ad, entry: 0x000003ac, offset: 0x03ac
FAT16: entry: 0x000003ad = 941, offset: 0x03ad = 941
FAT16: ret: 0x000003ae, entry: 0x000003ad, offset: 0x03ad
FAT16: entry: 0x000003ae = 942, offset: 0x03ae = 942
FAT16: ret: 0x000003af, entry: 0x000003ae, offset: 0x03ae
FAT16: entry: 0x000003af = 943, offset: 0x03af = 943
FAT16: ret: 0x000003b0, entry: 0x000003af, offset: 0x03af
FAT16: entry: 0x000003b0 = 944, offset: 0x03b0 = 944
FAT16: ret: 0x000003b1, entry: 0x000003b0, offset: 0x03b0
FAT16: entry: 0x000003b1 = 945, offset: 0x03b1 = 945
FAT16: ret: 0x000003b2, entry: 0x000003b1, offset: 0x03b1
FAT16: entry: 0x000003b2 = 946, offset: 0x03b2 = 946
FAT16: ret: 0x000003b3, entry: 0x000003b2, offset: 0x03b2
FAT16: entry: 0x000003b3 = 947, offset: 0x03b3 = 947
FAT16: ret: 0x000003b4, entry: 0x000003b3, offset: 0x03b3
FAT16: entry: 0x000003b4 = 948, offset: 0x03b4 = 948
FAT16: ret: 0x000003b5, entry: 0x000003b4, offset: 0x03b4
FAT16: entry: 0x000003b5 = 949, offset: 0x03b5 = 949
FAT16: ret: 0x000003b6, entry: 0x000003b5, offset: 0x03b5
FAT16: entry: 0x000003b6 = 950, offset: 0x03b6 = 950
FAT16: ret: 0x000003b7, entry: 0x000003b6, offset: 0x03b6
FAT16: entry: 0x000003b7 = 951, offset: 0x03b7 = 951
FAT16: ret: 0x000003b8, entry: 0x000003b7, offset: 0x03b7
FAT16: entry: 0x000003b8 = 952, offset: 0x03b8 = 952
FAT16: ret: 0x000003b9, entry: 0x000003b8, offset: 0x03b8
FAT16: entry: 0x000003b9 = 953, offset: 0x03b9 = 953
FAT16: ret: 0x000003ba, entry: 0x000003b9, offset: 0x03b9
FAT16: entry: 0x000003ba = 954, offset: 0x03ba = 954
FAT16: ret: 0x000003bb, entry: 0x000003ba, offset: 0x03ba
FAT16: entry: 0x000003bb = 955, offset: 0x03bb = 955
FAT16: ret: 0x000003bc, entry: 0x000003bb, offset: 0x03bb
FAT16: entry: 0x000003bc = 956, offset: 0x03bc = 956
FAT16: ret: 0x000003bd, entry: 0x000003bc, offset: 0x03bc
FAT16: entry: 0x000003bd = 957, offset: 0x03bd = 957
FAT16: ret: 0x000003be, entry: 0x000003bd, offset: 0x03bd
FAT16: entry: 0x000003be = 958, offset: 0x03be = 958
FAT16: ret: 0x000003bf, entry: 0x000003be, offset: 0x03be
FAT16: entry: 0x000003bf = 959, offset: 0x03bf = 959
FAT16: ret: 0x000003c0, entry: 0x000003bf, offset: 0x03bf
FAT16: entry: 0x000003c0 = 960, offset: 0x03c0 = 960
FAT16: ret: 0x000003c1, entry: 0x000003c0, offset: 0x03c0
FAT16: entry: 0x000003c1 = 961, offset: 0x03c1 = 961
FAT16: ret: 0x000003c2, entry: 0x000003c1, offset: 0x03c1
FAT16: entry: 0x000003c2 = 962, offset: 0x03c2 = 962
FAT16: ret: 0x000003c3, entry: 0x000003c2, offset: 0x03c2
FAT16: entry: 0x000003c3 = 963, offset: 0x03c3 = 963
FAT16: ret: 0x000003c4, entry: 0x000003c3, offset: 0x03c3
FAT16: entry: 0x000003c4 = 964, offset: 0x03c4 = 964
FAT16: ret: 0x000003c5, entry: 0x000003c4, offset: 0x03c4
FAT16: entry: 0x000003c5 = 965, offset: 0x03c5 = 965
FAT16: ret: 0x000003c6, entry: 0x000003c5, offset: 0x03c5
FAT16: entry: 0x000003c6 = 966, offset: 0x03c6 = 966
FAT16: ret: 0x000003c7, entry: 0x000003c6, offset: 0x03c6
FAT16: entry: 0x000003c7 = 967, offset: 0x03c7 = 967
FAT16: ret: 0x000003c8, entry: 0x000003c7, offset: 0x03c7
FAT16: entry: 0x000003c8 = 968, offset: 0x03c8 = 968
FAT16: ret: 0x000003c9, entry: 0x000003c8, offset: 0x03c8
FAT16: entry: 0x000003c9 = 969, offset: 0x03c9 = 969
FAT16: ret: 0x000003ca, entry: 0x000003c9, offset: 0x03c9
FAT16: entry: 0x000003ca = 970, offset: 0x03ca = 970
FAT16: ret: 0x000003cb, entry: 0x000003ca, offset: 0x03ca
FAT16: entry: 0x000003cb = 971, offset: 0x03cb = 971
FAT16: ret: 0x000003cc, entry: 0x000003cb, offset: 0x03cb
FAT16: entry: 0x000003cc = 972, offset: 0x03cc = 972
FAT16: ret: 0x000003cd, entry: 0x000003cc, offset: 0x03cc
FAT16: entry: 0x000003cd = 973, offset: 0x03cd = 973
FAT16: ret: 0x000003ce, entry: 0x000003cd, offset: 0x03cd
FAT16: entry: 0x000003ce = 974, offset: 0x03ce = 974
FAT16: ret: 0x000003cf, entry: 0x000003ce, offset: 0x03ce
FAT16: entry: 0x000003cf = 975, offset: 0x03cf = 975
FAT16: ret: 0x000003d0, entry: 0x000003cf, offset: 0x03cf
FAT16: entry: 0x000003d0 = 976, offset: 0x03d0 = 976
FAT16: ret: 0x000003d1, entry: 0x000003d0, offset: 0x03d0
FAT16: entry: 0x000003d1 = 977, offset: 0x03d1 = 977
FAT16: ret: 0x000003d2, entry: 0x000003d1, offset: 0x03d1
FAT16: entry: 0x000003d2 = 978, offset: 0x03d2 = 978
FAT16: ret: 0x000003d3, entry: 0x000003d2, offset: 0x03d2
FAT16: entry: 0x000003d3 = 979, offset: 0x03d3 = 979
FAT16: ret: 0x000003d4, entry: 0x000003d3, offset: 0x03d3
FAT16: entry: 0x000003d4 = 980, offset: 0x03d4 = 980
FAT16: ret: 0x000003d5, entry: 0x000003d4, offset: 0x03d4
FAT16: entry: 0x000003d5 = 981, offset: 0x03d5 = 981
FAT16: ret: 0x000003d6, entry: 0x000003d5, offset: 0x03d5
FAT16: entry: 0x000003d6 = 982, offset: 0x03d6 = 982
FAT16: ret: 0x000003d7, entry: 0x000003d6, offset: 0x03d6
FAT16: entry: 0x000003d7 = 983, offset: 0x03d7 = 983
FAT16: ret: 0x000003d8, entry: 0x000003d7, offset: 0x03d7
FAT16: entry: 0x000003d8 = 984, offset: 0x03d8 = 984
FAT16: ret: 0x000003d9, entry: 0x000003d8, offset: 0x03d8
FAT16: entry: 0x000003d9 = 985, offset: 0x03d9 = 985
FAT16: ret: 0x000003da, entry: 0x000003d9, offset: 0x03d9
FAT16: entry: 0x000003da = 986, offset: 0x03da = 986
FAT16: ret: 0x000003db, entry: 0x000003da, offset: 0x03da
FAT16: entry: 0x000003db = 987, offset: 0x03db = 987
FAT16: ret: 0x000003dc, entry: 0x000003db, offset: 0x03db
FAT16: entry: 0x000003dc = 988, offset: 0x03dc = 988
FAT16: ret: 0x000003dd, entry: 0x000003dc, offset: 0x03dc
FAT16: entry: 0x000003dd = 989, offset: 0x03dd = 989
FAT16: ret: 0x000003de, entry: 0x000003dd, offset: 0x03dd
FAT16: entry: 0x000003de = 990, offset: 0x03de = 990
FAT16: ret: 0x000003df, entry: 0x000003de, offset: 0x03de
FAT16: entry: 0x000003df = 991, offset: 0x03df = 991
FAT16: ret: 0x000003e0, entry: 0x000003df, offset: 0x03df
FAT16: entry: 0x000003e0 = 992, offset: 0x03e0 = 992
FAT16: ret: 0x000003e1, entry: 0x000003e0, offset: 0x03e0
FAT16: entry: 0x000003e1 = 993, offset: 0x03e1 = 993
FAT16: ret: 0x000003e2, entry: 0x000003e1, offset: 0x03e1
FAT16: entry: 0x000003e2 = 994, offset: 0x03e2 = 994
FAT16: ret: 0x000003e3, entry: 0x000003e2, offset: 0x03e2
FAT16: entry: 0x000003e3 = 995, offset: 0x03e3 = 995
FAT16: ret: 0x000003e4, entry: 0x000003e3, offset: 0x03e3
FAT16: entry: 0x000003e4 = 996, offset: 0x03e4 = 996
FAT16: ret: 0x000003e5, entry: 0x000003e4, offset: 0x03e4
FAT16: entry: 0x000003e5 = 997, offset: 0x03e5 = 997
FAT16: ret: 0x000003e6, entry: 0x000003e5, offset: 0x03e5
FAT16: entry: 0x000003e6 = 998, offset: 0x03e6 = 998
FAT16: ret: 0x000003e7, entry: 0x000003e6, offset: 0x03e6
FAT16: entry: 0x000003e7 = 999, offset: 0x03e7 = 999
FAT16: ret: 0x000003e8, entry: 0x000003e7, offset: 0x03e7
FAT16: entry: 0x000003e8 = 1000, offset: 0x03e8 = 1000
FAT16: ret: 0x000003e9, entry: 0x000003e8, offset: 0x03e8
FAT16: entry: 0x000003e9 = 1001, offset: 0x03e9 = 1001
FAT16: ret: 0x000003ea, entry: 0x000003e9, offset: 0x03e9
FAT16: entry: 0x000003ea = 1002, offset: 0x03ea = 1002
FAT16: ret: 0x000003eb, entry: 0x000003ea, offset: 0x03ea
FAT16: entry: 0x000003eb = 1003, offset: 0x03eb = 1003
FAT16: ret: 0x000003ec, entry: 0x000003eb, offset: 0x03eb
FAT16: entry: 0x000003ec = 1004, offset: 0x03ec = 1004
FAT16: ret: 0x000003ed, entry: 0x000003ec, offset: 0x03ec
FAT16: entry: 0x000003ed = 1005, offset: 0x03ed = 1005
FAT16: ret: 0x000003ee, entry: 0x000003ed, offset: 0x03ed
FAT16: entry: 0x000003ee = 1006, offset: 0x03ee = 1006
FAT16: ret: 0x000003ef, entry: 0x000003ee, offset: 0x03ee
FAT16: entry: 0x000003ef = 1007, offset: 0x03ef = 1007
FAT16: ret: 0x000003f0, entry: 0x000003ef, offset: 0x03ef
FAT16: entry: 0x000003f0 = 1008, offset: 0x03f0 = 1008
FAT16: ret: 0x000003f1, entry: 0x000003f0, offset: 0x03f0
FAT16: entry: 0x000003f1 = 1009, offset: 0x03f1 = 1009
FAT16: ret: 0x000003f2, entry: 0x000003f1, offset: 0x03f1
FAT16: entry: 0x000003f2 = 1010, offset: 0x03f2 = 1010
FAT16: ret: 0x000003f3, entry: 0x000003f2, offset: 0x03f2
FAT16: entry: 0x000003f3 = 1011, offset: 0x03f3 = 1011
FAT16: ret: 0x000003f4, entry: 0x000003f3, offset: 0x03f3
FAT16: entry: 0x000003f4 = 1012, offset: 0x03f4 = 1012
FAT16: ret: 0x000003f5, entry: 0x000003f4, offset: 0x03f4
FAT16: entry: 0x000003f5 = 1013, offset: 0x03f5 = 1013
FAT16: ret: 0x000003f6, entry: 0x000003f5, offset: 0x03f5
FAT16: entry: 0x000003f6 = 1014, offset: 0x03f6 = 1014
FAT16: ret: 0x000005f7, entry: 0x000003f6, offset: 0x03f6
FAT16: entry: 0x000005f7 = 1527, offset: 0x05f7 = 1527
FAT16: ret: 0x000005f8, entry: 0x000005f7, offset: 0x05f7
FAT16: entry: 0x000005f8 = 1528, offset: 0x05f8 = 1528
FAT16: ret: 0x000005f9, entry: 0x000005f8, offset: 0x05f8
FAT16: entry: 0x000005f9 = 1529, offset: 0x05f9 = 1529
FAT16: ret: 0x000005fa, entry: 0x000005f9, offset: 0x05f9
FAT16: entry: 0x000005fa = 1530, offset: 0x05fa = 1530
FAT16: ret: 0x000005fb, entry: 0x000005fa, offset: 0x05fa
FAT16: entry: 0x000005fb = 1531, offset: 0x05fb = 1531
FAT16: ret: 0x000005fc, entry: 0x000005fb, offset: 0x05fb
FAT16: entry: 0x000005fc = 1532, offset: 0x05fc = 1532
FAT16: ret: 0x000005fd, entry: 0x000005fc, offset: 0x05fc
FAT16: entry: 0x000005fd = 1533, offset: 0x05fd = 1533
FAT16: ret: 0x000005fe, entry: 0x000005fd, offset: 0x05fd
FAT16: entry: 0x000005fe = 1534, offset: 0x05fe = 1534
FAT16: ret: 0x000005ff, entry: 0x000005fe, offset: 0x05fe
FAT16: entry: 0x000005ff = 1535, offset: 0x05ff = 1535
FAT16: ret: 0x00000600, entry: 0x000005ff, offset: 0x05ff
FAT16: entry: 0x00000600 = 1536, offset: 0x0000 = 0
debug: evicting 0, dirty: 0
FAT16: ret: 0x00000601, entry: 0x00000600, offset: 0x0000
FAT16: entry: 0x00000601 = 1537, offset: 0x0001 = 1
FAT16: ret: 0x00000602, entry: 0x00000601, offset: 0x0001
FAT16: entry: 0x00000602 = 1538, offset: 0x0002 = 2
FAT16: ret: 0x00000603, entry: 0x00000602, offset: 0x0002
FAT16: entry: 0x00000603 = 1539, offset: 0x0003 = 3
FAT16: ret: 0x00000604, entry: 0x00000603, offset: 0x0003
FAT16: entry: 0x00000604 = 1540, offset: 0x0004 = 4
FAT16: ret: 0x00000605, entry: 0x00000604, offset: 0x0004
FAT16: entry: 0x00000605 = 1541, offset: 0x0005 = 5
FAT16: ret: 0x00000606, entry: 0x00000605, offset: 0x0005
FAT16: entry: 0x00000606 = 1542, offset: 0x0006 = 6
FAT16: ret: 0x00000607, entry: 0x00000606, offset: 0x0006
FAT16: entry: 0x00000607 = 1543, offset: 0x0007 = 7
FAT16: ret: 0x00000608, entry: 0x00000607, offset: 0x0007
FAT16: entry: 0x00000608 = 1544, offset: 0x0008 = 8
FAT16: ret: 0x00000609, entry: 0x00000608, offset: 0x0008
FAT16: entry: 0x00000609 = 1545, offset: 0x0009 = 9
FAT16: ret: 0x0000060a, entry: 0x00000609, offset: 0x0009
FAT16: entry: 0x0000060a = 1546, offset: 0x000a = 10
FAT16: ret: 0x0000060b, entry: 0x0000060a, offset: 0x000a
FAT16: entry: 0x0000060b = 1547, offset: 0x000b = 11
FAT16: ret: 0x0000060c, entry: 0x0000060b, offset: 0x000b
FAT16: entry: 0x0000060c = 1548, offset: 0x000c = 12
FAT16: ret: 0x0000060d, entry: 0x0000060c, offset: 0x000c
FAT16: entry: 0x0000060d = 1549, offset: 0x000d = 13
FAT16: ret: 0x0000060e, entry: 0x0000060d, offset: 0x000d
FAT16: entry: 0x0000060e = 1550, offset: 0x000e = 14
FAT16: ret: 0x0000060f, entry: 0x0000060e, offset: 0x000e
FAT16: entry: 0x0000060f = 1551, offset: 0x000f = 15
FAT16: ret: 0x00000610, entry: 0x0000060f, offset: 0x000f
FAT16: entry: 0x00000610 = 1552, offset: 0x0010 = 16
FAT16: ret: 0x00000611, entry: 0x00000610, offset: 0x0010
FAT16: entry: 0x00000611 = 1553, offset: 0x0011 = 17
FAT16: ret: 0x00000612, entry: 0x00000611, offset: 0x0011
FAT16: entry: 0x00000612 = 1554, offset: 0x0012 = 18
FAT16: ret: 0x00000613, entry: 0x00000612, offset: 0x0012
FAT16: entry: 0x00000613 = 1555, offset: 0x0013 = 19
FAT16: ret: 0x00000614, entry: 0x00000613, offset: 0x0013
FAT16: entry: 0x00000614 = 1556, offset: 0x0014 = 20
FAT16: ret: 0x00000615, entry: 0x00000614, offset: 0x0014
FAT16: entry: 0x00000615 = 1557, offset: 0x0015 = 21
FAT16: ret: 0x00000616, entry: 0x00000615, offset: 0x0015
FAT16: entry: 0x00000616 = 1558, offset: 0x0016 = 22
FAT16: ret: 0x00000617, entry: 0x00000616, offset: 0x0016
FAT16: entry: 0x00000617 = 1559, offset: 0x0017 = 23
FAT16: ret: 0x00000618, entry: 0x00000617, offset: 0x0017
FAT16: entry: 0x00000618 = 1560, offset: 0x0018 = 24
FAT16: ret: 0x00000619, entry: 0x00000618, offset: 0x0018
FAT16: entry: 0x00000619 = 1561, offset: 0x0019 = 25
FAT16: ret: 0x0000061a, entry: 0x00000619, offset: 0x0019
FAT16: entry: 0x0000061a = 1562, offset: 0x001a = 26
FAT16: ret: 0x0000061b, entry: 0x0000061a, offset: 0x001a
FAT16: entry: 0x0000061b = 1563, offset: 0x001b = 27
FAT16: ret: 0x0000061c, entry: 0x0000061b, offset: 0x001b
FAT16: entry: 0x0000061c = 1564, offset: 0x001c = 28
FAT16: ret: 0x0000061d, entry: 0x0000061c, offset: 0x001c
FAT16: entry: 0x0000061d = 1565, offset: 0x001d = 29
FAT16: ret: 0x0000061e, entry: 0x0000061d, offset: 0x001d
FAT16: entry: 0x0000061e = 1566, offset: 0x001e = 30
FAT16: ret: 0x0000061f, entry: 0x0000061e, offset: 0x001e
FAT16: entry: 0x0000061f = 1567, offset: 0x001f = 31
FAT16: ret: 0x00000620, entry: 0x0000061f, offset: 0x001f
FAT16: entry: 0x00000620 = 1568, offset: 0x0020 = 32
FAT16: ret: 0x00000621, entry: 0x00000620, offset: 0x0020
FAT16: entry: 0x00000621 = 1569, offset: 0x0021 = 33
FAT16: ret: 0x00000622, entry: 0x00000621, offset: 0x0021
FAT16: entry: 0x00000622 = 1570, offset: 0x0022 = 34
FAT16: ret: 0x00000623, entry: 0x00000622, offset: 0x0022
FAT16: entry: 0x00000623 = 1571, offset: 0x0023 = 35
FAT16: ret: 0x00000624, entry: 0x00000623, offset: 0x0023
FAT16: entry: 0x00000624 = 1572, offset: 0x0024 = 36
FAT16: ret: 0x00000625, entry: 0x00000624, offset: 0x0024
FAT16: entry: 0x00000625 = 1573, offset: 0x0025 = 37
FAT16: ret: 0x00000626, entry: 0x00000625, offset: 0x0025
FAT16: entry: 0x00000626 = 1574, offset: 0x0026 = 38
FAT16: ret: 0x00000627, entry: 0x00000626, offset: 0x0026
FAT16: entry: 0x00000627 = 1575, offset: 0x0027 = 39
FAT16: ret: 0x00000628, entry: 0x00000627, offset: 0x0027
FAT16: entry: 0x00000628 = 1576, offset: 0x0028 = 40
FAT16: ret: 0x00000629, entry: 0x00000628, offset: 0x0028
FAT16: entry: 0x00000629 = 1577, offset: 0x0029 = 41
FAT16: ret: 0x0000062a, entry: 0x00000629, offset: 0x0029
FAT16: entry: 0x0000062a = 1578, offset: 0x002a = 42
FAT16: ret: 0x0000062b, entry: 0x0000062a, offset: 0x002a
FAT16: entry: 0x0000062b = 1579, offset: 0x002b = 43
FAT16: ret: 0x0000062c, entry: 0x0000062b, offset: 0x002b
clustnum: 525, startsect: 2525, pos: 0
FAT16: entry: 0x0000062c = 1580, offset: 0x002c = 44
FAT16: ret: 0x0000ffff, entry: 0x0000062c, offset: 0x002c
attempt to write 0x100000 bytes
debug: evicting 1, dirty: 0
clustnum: -6, startsect: 401
1048576 bytes written
switch to partitions #0, OK
mmc1(part 0) is current device
switch to partitions #0, OK
mmc0 is current device
READING!
FAT16, fat_sect: 1, fatlength: 200
Rootdir begins at cluster: -6, sector: 401, offset: 32200
Data begins at: 425
Sector size: 512, cluster size: 4
FAT read(sect=401), clust_size=4, DIRENTSPERBLOCK=16
reading u-boot.img at pos 0
Filesize: 1048576 bytes
1048576 bytes
FAT16: entry: 0x0000020d = 525, offset: 0x020d = 525
debug: evicting -1, dirty: 0
FAT16: ret: 0x0000020e, entry: 0x0000020d, offset: 0x020d
FAT16: entry: 0x0000020e = 526, offset: 0x020e = 526
FAT16: ret: 0x0000020f, entry: 0x0000020e, offset: 0x020e
FAT16: entry: 0x0000020f = 527, offset: 0x020f = 527
FAT16: ret: 0x00000210, entry: 0x0000020f, offset: 0x020f
FAT16: entry: 0x00000210 = 528, offset: 0x0210 = 528
FAT16: ret: 0x00000211, entry: 0x00000210, offset: 0x0210
FAT16: entry: 0x00000211 = 529, offset: 0x0211 = 529
FAT16: ret: 0x00000212, entry: 0x00000211, offset: 0x0211
FAT16: entry: 0x00000212 = 530, offset: 0x0212 = 530
FAT16: ret: 0x00000213, entry: 0x00000212, offset: 0x0212
FAT16: entry: 0x00000213 = 531, offset: 0x0213 = 531
FAT16: ret: 0x00000214, entry: 0x00000213, offset: 0x0213
FAT16: entry: 0x00000214 = 532, offset: 0x0214 = 532
FAT16: ret: 0x00000215, entry: 0x00000214, offset: 0x0214
FAT16: entry: 0x00000215 = 533, offset: 0x0215 = 533
FAT16: ret: 0x00000216, entry: 0x00000215, offset: 0x0215
FAT16: entry: 0x00000216 = 534, offset: 0x0216 = 534
FAT16: ret: 0x00000217, entry: 0x00000216, offset: 0x0216
FAT16: entry: 0x00000217 = 535, offset: 0x0217 = 535
FAT16: ret: 0x00000218, entry: 0x00000217, offset: 0x0217
FAT16: entry: 0x00000218 = 536, offset: 0x0218 = 536
FAT16: ret: 0x00000219, entry: 0x00000218, offset: 0x0218
FAT16: entry: 0x00000219 = 537, offset: 0x0219 = 537
FAT16: ret: 0x0000021a, entry: 0x00000219, offset: 0x0219
FAT16: entry: 0x0000021a = 538, offset: 0x021a = 538
FAT16: ret: 0x0000021b, entry: 0x0000021a, offset: 0x021a
FAT16: entry: 0x0000021b = 539, offset: 0x021b = 539
FAT16: ret: 0x0000021c, entry: 0x0000021b, offset: 0x021b
FAT16: entry: 0x0000021c = 540, offset: 0x021c = 540
FAT16: ret: 0x0000021d, entry: 0x0000021c, offset: 0x021c
FAT16: entry: 0x0000021d = 541, offset: 0x021d = 541
FAT16: ret: 0x0000021e, entry: 0x0000021d, offset: 0x021d
FAT16: entry: 0x0000021e = 542, offset: 0x021e = 542
FAT16: ret: 0x0000021f, entry: 0x0000021e, offset: 0x021e
FAT16: entry: 0x0000021f = 543, offset: 0x021f = 543
FAT16: ret: 0x00000220, entry: 0x0000021f, offset: 0x021f
FAT16: entry: 0x00000220 = 544, offset: 0x0220 = 544
FAT16: ret: 0x00000221, entry: 0x00000220, offset: 0x0220
FAT16: entry: 0x00000221 = 545, offset: 0x0221 = 545
FAT16: ret: 0x00000222, entry: 0x00000221, offset: 0x0221
FAT16: entry: 0x00000222 = 546, offset: 0x0222 = 546
FAT16: ret: 0x00000223, entry: 0x00000222, offset: 0x0222
FAT16: entry: 0x00000223 = 547, offset: 0x0223 = 547
FAT16: ret: 0x00000224, entry: 0x00000223, offset: 0x0223
FAT16: entry: 0x00000224 = 548, offset: 0x0224 = 548
FAT16: ret: 0x00000225, entry: 0x00000224, offset: 0x0224
FAT16: entry: 0x00000225 = 549, offset: 0x0225 = 549
FAT16: ret: 0x00000226, entry: 0x00000225, offset: 0x0225
FAT16: entry: 0x00000226 = 550, offset: 0x0226 = 550
FAT16: ret: 0x00000227, entry: 0x00000226, offset: 0x0226
FAT16: entry: 0x00000227 = 551, offset: 0x0227 = 551
FAT16: ret: 0x00000228, entry: 0x00000227, offset: 0x0227
FAT16: entry: 0x00000228 = 552, offset: 0x0228 = 552
FAT16: ret: 0x00000229, entry: 0x00000228, offset: 0x0228
FAT16: entry: 0x00000229 = 553, offset: 0x0229 = 553
FAT16: ret: 0x0000022a, entry: 0x00000229, offset: 0x0229
FAT16: entry: 0x0000022a = 554, offset: 0x022a = 554
FAT16: ret: 0x0000022b, entry: 0x0000022a, offset: 0x022a
FAT16: entry: 0x0000022b = 555, offset: 0x022b = 555
FAT16: ret: 0x0000022c, entry: 0x0000022b, offset: 0x022b
FAT16: entry: 0x0000022c = 556, offset: 0x022c = 556
FAT16: ret: 0x0000022d, entry: 0x0000022c, offset: 0x022c
FAT16: entry: 0x0000022d = 557, offset: 0x022d = 557
FAT16: ret: 0x0000022e, entry: 0x0000022d, offset: 0x022d
FAT16: entry: 0x0000022e = 558, offset: 0x022e = 558
FAT16: ret: 0x0000022f, entry: 0x0000022e, offset: 0x022e
FAT16: entry: 0x0000022f = 559, offset: 0x022f = 559
FAT16: ret: 0x00000230, entry: 0x0000022f, offset: 0x022f
FAT16: entry: 0x00000230 = 560, offset: 0x0230 = 560
FAT16: ret: 0x00000231, entry: 0x00000230, offset: 0x0230
FAT16: entry: 0x00000231 = 561, offset: 0x0231 = 561
FAT16: ret: 0x00000232, entry: 0x00000231, offset: 0x0231
FAT16: entry: 0x00000232 = 562, offset: 0x0232 = 562
FAT16: ret: 0x00000233, entry: 0x00000232, offset: 0x0232
FAT16: entry: 0x00000233 = 563, offset: 0x0233 = 563
FAT16: ret: 0x00000234, entry: 0x00000233, offset: 0x0233
FAT16: entry: 0x00000234 = 564, offset: 0x0234 = 564
FAT16: ret: 0x00000235, entry: 0x00000234, offset: 0x0234
FAT16: entry: 0x00000235 = 565, offset: 0x0235 = 565
FAT16: ret: 0x00000236, entry: 0x00000235, offset: 0x0235
FAT16: entry: 0x00000236 = 566, offset: 0x0236 = 566
FAT16: ret: 0x00000237, entry: 0x00000236, offset: 0x0236
FAT16: entry: 0x00000237 = 567, offset: 0x0237 = 567
FAT16: ret: 0x00000238, entry: 0x00000237, offset: 0x0237
FAT16: entry: 0x00000238 = 568, offset: 0x0238 = 568
FAT16: ret: 0x00000239, entry: 0x00000238, offset: 0x0238
FAT16: entry: 0x00000239 = 569, offset: 0x0239 = 569
FAT16: ret: 0x0000023a, entry: 0x00000239, offset: 0x0239
FAT16: entry: 0x0000023a = 570, offset: 0x023a = 570
FAT16: ret: 0x0000023b, entry: 0x0000023a, offset: 0x023a
FAT16: entry: 0x0000023b = 571, offset: 0x023b = 571
FAT16: ret: 0x0000023c, entry: 0x0000023b, offset: 0x023b
FAT16: entry: 0x0000023c = 572, offset: 0x023c = 572
FAT16: ret: 0x0000023d, entry: 0x0000023c, offset: 0x023c
FAT16: entry: 0x0000023d = 573, offset: 0x023d = 573
FAT16: ret: 0x0000023e, entry: 0x0000023d, offset: 0x023d
FAT16: entry: 0x0000023e = 574, offset: 0x023e = 574
FAT16: ret: 0x0000023f, entry: 0x0000023e, offset: 0x023e
FAT16: entry: 0x0000023f = 575, offset: 0x023f = 575
FAT16: ret: 0x00000240, entry: 0x0000023f, offset: 0x023f
FAT16: entry: 0x00000240 = 576, offset: 0x0240 = 576
FAT16: ret: 0x00000241, entry: 0x00000240, offset: 0x0240
FAT16: entry: 0x00000241 = 577, offset: 0x0241 = 577
FAT16: ret: 0x00000242, entry: 0x00000241, offset: 0x0241
FAT16: entry: 0x00000242 = 578, offset: 0x0242 = 578
FAT16: ret: 0x00000243, entry: 0x00000242, offset: 0x0242
FAT16: entry: 0x00000243 = 579, offset: 0x0243 = 579
FAT16: ret: 0x00000244, entry: 0x00000243, offset: 0x0243
FAT16: entry: 0x00000244 = 580, offset: 0x0244 = 580
FAT16: ret: 0x00000245, entry: 0x00000244, offset: 0x0244
FAT16: entry: 0x00000245 = 581, offset: 0x0245 = 581
FAT16: ret: 0x00000246, entry: 0x00000245, offset: 0x0245
FAT16: entry: 0x00000246 = 582, offset: 0x0246 = 582
FAT16: ret: 0x00000247, entry: 0x00000246, offset: 0x0246
FAT16: entry: 0x00000247 = 583, offset: 0x0247 = 583
FAT16: ret: 0x00000248, entry: 0x00000247, offset: 0x0247
FAT16: entry: 0x00000248 = 584, offset: 0x0248 = 584
FAT16: ret: 0x00000249, entry: 0x00000248, offset: 0x0248
FAT16: entry: 0x00000249 = 585, offset: 0x0249 = 585
FAT16: ret: 0x0000024a, entry: 0x00000249, offset: 0x0249
FAT16: entry: 0x0000024a = 586, offset: 0x024a = 586
FAT16: ret: 0x0000024b, entry: 0x0000024a, offset: 0x024a
FAT16: entry: 0x0000024b = 587, offset: 0x024b = 587
FAT16: ret: 0x0000024c, entry: 0x0000024b, offset: 0x024b
FAT16: entry: 0x0000024c = 588, offset: 0x024c = 588
FAT16: ret: 0x0000024d, entry: 0x0000024c, offset: 0x024c
FAT16: entry: 0x0000024d = 589, offset: 0x024d = 589
FAT16: ret: 0x0000024e, entry: 0x0000024d, offset: 0x024d
FAT16: entry: 0x0000024e = 590, offset: 0x024e = 590
FAT16: ret: 0x0000024f, entry: 0x0000024e, offset: 0x024e
FAT16: entry: 0x0000024f = 591, offset: 0x024f = 591
FAT16: ret: 0x00000250, entry: 0x0000024f, offset: 0x024f
FAT16: entry: 0x00000250 = 592, offset: 0x0250 = 592
FAT16: ret: 0x00000251, entry: 0x00000250, offset: 0x0250
FAT16: entry: 0x00000251 = 593, offset: 0x0251 = 593
FAT16: ret: 0x00000252, entry: 0x00000251, offset: 0x0251
FAT16: entry: 0x00000252 = 594, offset: 0x0252 = 594
FAT16: ret: 0x00000253, entry: 0x00000252, offset: 0x0252
FAT16: entry: 0x00000253 = 595, offset: 0x0253 = 595
FAT16: ret: 0x00000254, entry: 0x00000253, offset: 0x0253
FAT16: entry: 0x00000254 = 596, offset: 0x0254 = 596
FAT16: ret: 0x00000255, entry: 0x00000254, offset: 0x0254
FAT16: entry: 0x00000255 = 597, offset: 0x0255 = 597
FAT16: ret: 0x00000256, entry: 0x00000255, offset: 0x0255
FAT16: entry: 0x00000256 = 598, offset: 0x0256 = 598
FAT16: ret: 0x00000257, entry: 0x00000256, offset: 0x0256
FAT16: entry: 0x00000257 = 599, offset: 0x0257 = 599
FAT16: ret: 0x00000258, entry: 0x00000257, offset: 0x0257
FAT16: entry: 0x00000258 = 600, offset: 0x0258 = 600
FAT16: ret: 0x00000259, entry: 0x00000258, offset: 0x0258
FAT16: entry: 0x00000259 = 601, offset: 0x0259 = 601
FAT16: ret: 0x0000025a, entry: 0x00000259, offset: 0x0259
FAT16: entry: 0x0000025a = 602, offset: 0x025a = 602
FAT16: ret: 0x0000025b, entry: 0x0000025a, offset: 0x025a
FAT16: entry: 0x0000025b = 603, offset: 0x025b = 603
FAT16: ret: 0x0000025c, entry: 0x0000025b, offset: 0x025b
FAT16: entry: 0x0000025c = 604, offset: 0x025c = 604
FAT16: ret: 0x0000025d, entry: 0x0000025c, offset: 0x025c
FAT16: entry: 0x0000025d = 605, offset: 0x025d = 605
FAT16: ret: 0x0000025e, entry: 0x0000025d, offset: 0x025d
FAT16: entry: 0x0000025e = 606, offset: 0x025e = 606
FAT16: ret: 0x0000025f, entry: 0x0000025e, offset: 0x025e
FAT16: entry: 0x0000025f = 607, offset: 0x025f = 607
FAT16: ret: 0x00000260, entry: 0x0000025f, offset: 0x025f
FAT16: entry: 0x00000260 = 608, offset: 0x0260 = 608
FAT16: ret: 0x00000261, entry: 0x00000260, offset: 0x0260
FAT16: entry: 0x00000261 = 609, offset: 0x0261 = 609
FAT16: ret: 0x00000262, entry: 0x00000261, offset: 0x0261
FAT16: entry: 0x00000262 = 610, offset: 0x0262 = 610
FAT16: ret: 0x00000263, entry: 0x00000262, offset: 0x0262
FAT16: entry: 0x00000263 = 611, offset: 0x0263 = 611
FAT16: ret: 0x00000264, entry: 0x00000263, offset: 0x0263
FAT16: entry: 0x00000264 = 612, offset: 0x0264 = 612
FAT16: ret: 0x00000265, entry: 0x00000264, offset: 0x0264
FAT16: entry: 0x00000265 = 613, offset: 0x0265 = 613
FAT16: ret: 0x00000266, entry: 0x00000265, offset: 0x0265
FAT16: entry: 0x00000266 = 614, offset: 0x0266 = 614
FAT16: ret: 0x00000267, entry: 0x00000266, offset: 0x0266
FAT16: entry: 0x00000267 = 615, offset: 0x0267 = 615
FAT16: ret: 0x00000268, entry: 0x00000267, offset: 0x0267
FAT16: entry: 0x00000268 = 616, offset: 0x0268 = 616
FAT16: ret: 0x00000269, entry: 0x00000268, offset: 0x0268
FAT16: entry: 0x00000269 = 617, offset: 0x0269 = 617
FAT16: ret: 0x0000026a, entry: 0x00000269, offset: 0x0269
FAT16: entry: 0x0000026a = 618, offset: 0x026a = 618
FAT16: ret: 0x0000026b, entry: 0x0000026a, offset: 0x026a
FAT16: entry: 0x0000026b = 619, offset: 0x026b = 619
FAT16: ret: 0x0000026c, entry: 0x0000026b, offset: 0x026b
FAT16: entry: 0x0000026c = 620, offset: 0x026c = 620
FAT16: ret: 0x0000026d, entry: 0x0000026c, offset: 0x026c
FAT16: entry: 0x0000026d = 621, offset: 0x026d = 621
FAT16: ret: 0x0000026e, entry: 0x0000026d, offset: 0x026d
FAT16: entry: 0x0000026e = 622, offset: 0x026e = 622
FAT16: ret: 0x0000026f, entry: 0x0000026e, offset: 0x026e
FAT16: entry: 0x0000026f = 623, offset: 0x026f = 623
FAT16: ret: 0x00000270, entry: 0x0000026f, offset: 0x026f
FAT16: entry: 0x00000270 = 624, offset: 0x0270 = 624
FAT16: ret: 0x00000271, entry: 0x00000270, offset: 0x0270
FAT16: entry: 0x00000271 = 625, offset: 0x0271 = 625
FAT16: ret: 0x00000272, entry: 0x00000271, offset: 0x0271
FAT16: entry: 0x00000272 = 626, offset: 0x0272 = 626
FAT16: ret: 0x00000273, entry: 0x00000272, offset: 0x0272
FAT16: entry: 0x00000273 = 627, offset: 0x0273 = 627
FAT16: ret: 0x00000274, entry: 0x00000273, offset: 0x0273
FAT16: entry: 0x00000274 = 628, offset: 0x0274 = 628
FAT16: ret: 0x00000275, entry: 0x00000274, offset: 0x0274
FAT16: entry: 0x00000275 = 629, offset: 0x0275 = 629
FAT16: ret: 0x00000276, entry: 0x00000275, offset: 0x0275
FAT16: entry: 0x00000276 = 630, offset: 0x0276 = 630
FAT16: ret: 0x00000277, entry: 0x00000276, offset: 0x0276
FAT16: entry: 0x00000277 = 631, offset: 0x0277 = 631
FAT16: ret: 0x00000278, entry: 0x00000277, offset: 0x0277
FAT16: entry: 0x00000278 = 632, offset: 0x0278 = 632
FAT16: ret: 0x00000279, entry: 0x00000278, offset: 0x0278
FAT16: entry: 0x00000279 = 633, offset: 0x0279 = 633
FAT16: ret: 0x0000027a, entry: 0x00000279, offset: 0x0279
FAT16: entry: 0x0000027a = 634, offset: 0x027a = 634
FAT16: ret: 0x0000027b, entry: 0x0000027a, offset: 0x027a
FAT16: entry: 0x0000027b = 635, offset: 0x027b = 635
FAT16: ret: 0x0000027c, entry: 0x0000027b, offset: 0x027b
FAT16: entry: 0x0000027c = 636, offset: 0x027c = 636
FAT16: ret: 0x0000027d, entry: 0x0000027c, offset: 0x027c
FAT16: entry: 0x0000027d = 637, offset: 0x027d = 637
FAT16: ret: 0x0000027e, entry: 0x0000027d, offset: 0x027d
FAT16: entry: 0x0000027e = 638, offset: 0x027e = 638
FAT16: ret: 0x0000027f, entry: 0x0000027e, offset: 0x027e
FAT16: entry: 0x0000027f = 639, offset: 0x027f = 639
FAT16: ret: 0x00000280, entry: 0x0000027f, offset: 0x027f
FAT16: entry: 0x00000280 = 640, offset: 0x0280 = 640
FAT16: ret: 0x00000281, entry: 0x00000280, offset: 0x0280
FAT16: entry: 0x00000281 = 641, offset: 0x0281 = 641
FAT16: ret: 0x00000282, entry: 0x00000281, offset: 0x0281
FAT16: entry: 0x00000282 = 642, offset: 0x0282 = 642
FAT16: ret: 0x00000283, entry: 0x00000282, offset: 0x0282
FAT16: entry: 0x00000283 = 643, offset: 0x0283 = 643
FAT16: ret: 0x00000284, entry: 0x00000283, offset: 0x0283
FAT16: entry: 0x00000284 = 644, offset: 0x0284 = 644
FAT16: ret: 0x00000285, entry: 0x00000284, offset: 0x0284
FAT16: entry: 0x00000285 = 645, offset: 0x0285 = 645
FAT16: ret: 0x00000286, entry: 0x00000285, offset: 0x0285
FAT16: entry: 0x00000286 = 646, offset: 0x0286 = 646
FAT16: ret: 0x00000287, entry: 0x00000286, offset: 0x0286
FAT16: entry: 0x00000287 = 647, offset: 0x0287 = 647
FAT16: ret: 0x00000288, entry: 0x00000287, offset: 0x0287
FAT16: entry: 0x00000288 = 648, offset: 0x0288 = 648
FAT16: ret: 0x00000289, entry: 0x00000288, offset: 0x0288
FAT16: entry: 0x00000289 = 649, offset: 0x0289 = 649
FAT16: ret: 0x0000028a, entry: 0x00000289, offset: 0x0289
FAT16: entry: 0x0000028a = 650, offset: 0x028a = 650
FAT16: ret: 0x0000028b, entry: 0x0000028a, offset: 0x028a
FAT16: entry: 0x0000028b = 651, offset: 0x028b = 651
FAT16: ret: 0x0000028c, entry: 0x0000028b, offset: 0x028b
FAT16: entry: 0x0000028c = 652, offset: 0x028c = 652
FAT16: ret: 0x0000028d, entry: 0x0000028c, offset: 0x028c
FAT16: entry: 0x0000028d = 653, offset: 0x028d = 653
FAT16: ret: 0x0000028e, entry: 0x0000028d, offset: 0x028d
FAT16: entry: 0x0000028e = 654, offset: 0x028e = 654
FAT16: ret: 0x0000028f, entry: 0x0000028e, offset: 0x028e
FAT16: entry: 0x0000028f = 655, offset: 0x028f = 655
FAT16: ret: 0x00000290, entry: 0x0000028f, offset: 0x028f
FAT16: entry: 0x00000290 = 656, offset: 0x0290 = 656
FAT16: ret: 0x00000291, entry: 0x00000290, offset: 0x0290
FAT16: entry: 0x00000291 = 657, offset: 0x0291 = 657
FAT16: ret: 0x00000292, entry: 0x00000291, offset: 0x0291
FAT16: entry: 0x00000292 = 658, offset: 0x0292 = 658
FAT16: ret: 0x00000293, entry: 0x00000292, offset: 0x0292
FAT16: entry: 0x00000293 = 659, offset: 0x0293 = 659
FAT16: ret: 0x00000294, entry: 0x00000293, offset: 0x0293
FAT16: entry: 0x00000294 = 660, offset: 0x0294 = 660
FAT16: ret: 0x00000295, entry: 0x00000294, offset: 0x0294
FAT16: entry: 0x00000295 = 661, offset: 0x0295 = 661
FAT16: ret: 0x00000296, entry: 0x00000295, offset: 0x0295
FAT16: entry: 0x00000296 = 662, offset: 0x0296 = 662
FAT16: ret: 0x00000297, entry: 0x00000296, offset: 0x0296
FAT16: entry: 0x00000297 = 663, offset: 0x0297 = 663
FAT16: ret: 0x00000298, entry: 0x00000297, offset: 0x0297
FAT16: entry: 0x00000298 = 664, offset: 0x0298 = 664
FAT16: ret: 0x00000299, entry: 0x00000298, offset: 0x0298
FAT16: entry: 0x00000299 = 665, offset: 0x0299 = 665
FAT16: ret: 0x0000029a, entry: 0x00000299, offset: 0x0299
FAT16: entry: 0x0000029a = 666, offset: 0x029a = 666
FAT16: ret: 0x0000029b, entry: 0x0000029a, offset: 0x029a
FAT16: entry: 0x0000029b = 667, offset: 0x029b = 667
FAT16: ret: 0x0000029c, entry: 0x0000029b, offset: 0x029b
FAT16: entry: 0x0000029c = 668, offset: 0x029c = 668
FAT16: ret: 0x0000029d, entry: 0x0000029c, offset: 0x029c
FAT16: entry: 0x0000029d = 669, offset: 0x029d = 669
FAT16: ret: 0x0000029e, entry: 0x0000029d, offset: 0x029d
FAT16: entry: 0x0000029e = 670, offset: 0x029e = 670
FAT16: ret: 0x0000029f, entry: 0x0000029e, offset: 0x029e
FAT16: entry: 0x0000029f = 671, offset: 0x029f = 671
FAT16: ret: 0x000002a0, entry: 0x0000029f, offset: 0x029f
FAT16: entry: 0x000002a0 = 672, offset: 0x02a0 = 672
FAT16: ret: 0x000002a1, entry: 0x000002a0, offset: 0x02a0
FAT16: entry: 0x000002a1 = 673, offset: 0x02a1 = 673
FAT16: ret: 0x000002a2, entry: 0x000002a1, offset: 0x02a1
FAT16: entry: 0x000002a2 = 674, offset: 0x02a2 = 674
FAT16: ret: 0x000002a3, entry: 0x000002a2, offset: 0x02a2
FAT16: entry: 0x000002a3 = 675, offset: 0x02a3 = 675
FAT16: ret: 0x000002a4, entry: 0x000002a3, offset: 0x02a3
FAT16: entry: 0x000002a4 = 676, offset: 0x02a4 = 676
FAT16: ret: 0x000002a5, entry: 0x000002a4, offset: 0x02a4
FAT16: entry: 0x000002a5 = 677, offset: 0x02a5 = 677
FAT16: ret: 0x000002a6, entry: 0x000002a5, offset: 0x02a5
FAT16: entry: 0x000002a6 = 678, offset: 0x02a6 = 678
FAT16: ret: 0x000002a7, entry: 0x000002a6, offset: 0x02a6
FAT16: entry: 0x000002a7 = 679, offset: 0x02a7 = 679
FAT16: ret: 0x000002a8, entry: 0x000002a7, offset: 0x02a7
FAT16: entry: 0x000002a8 = 680, offset: 0x02a8 = 680
FAT16: ret: 0x000002a9, entry: 0x000002a8, offset: 0x02a8
FAT16: entry: 0x000002a9 = 681, offset: 0x02a9 = 681
FAT16: ret: 0x000002aa, entry: 0x000002a9, offset: 0x02a9
FAT16: entry: 0x000002aa = 682, offset: 0x02aa = 682
FAT16: ret: 0x000002ab, entry: 0x000002aa, offset: 0x02aa
FAT16: entry: 0x000002ab = 683, offset: 0x02ab = 683
FAT16: ret: 0x000002ac, entry: 0x000002ab, offset: 0x02ab
FAT16: entry: 0x000002ac = 684, offset: 0x02ac = 684
FAT16: ret: 0x000002ad, entry: 0x000002ac, offset: 0x02ac
FAT16: entry: 0x000002ad = 685, offset: 0x02ad = 685
FAT16: ret: 0x000002ae, entry: 0x000002ad, offset: 0x02ad
FAT16: entry: 0x000002ae = 686, offset: 0x02ae = 686
FAT16: ret: 0x000002af, entry: 0x000002ae, offset: 0x02ae
FAT16: entry: 0x000002af = 687, offset: 0x02af = 687
FAT16: ret: 0x000002b0, entry: 0x000002af, offset: 0x02af
FAT16: entry: 0x000002b0 = 688, offset: 0x02b0 = 688
FAT16: ret: 0x000002b1, entry: 0x000002b0, offset: 0x02b0
FAT16: entry: 0x000002b1 = 689, offset: 0x02b1 = 689
FAT16: ret: 0x000002b2, entry: 0x000002b1, offset: 0x02b1
FAT16: entry: 0x000002b2 = 690, offset: 0x02b2 = 690
FAT16: ret: 0x000002b3, entry: 0x000002b2, offset: 0x02b2
FAT16: entry: 0x000002b3 = 691, offset: 0x02b3 = 691
FAT16: ret: 0x000002b4, entry: 0x000002b3, offset: 0x02b3
FAT16: entry: 0x000002b4 = 692, offset: 0x02b4 = 692
FAT16: ret: 0x000002b5, entry: 0x000002b4, offset: 0x02b4
FAT16: entry: 0x000002b5 = 693, offset: 0x02b5 = 693
FAT16: ret: 0x000002b6, entry: 0x000002b5, offset: 0x02b5
FAT16: entry: 0x000002b6 = 694, offset: 0x02b6 = 694
FAT16: ret: 0x000002b7, entry: 0x000002b6, offset: 0x02b6
FAT16: entry: 0x000002b7 = 695, offset: 0x02b7 = 695
FAT16: ret: 0x000002b8, entry: 0x000002b7, offset: 0x02b7
FAT16: entry: 0x000002b8 = 696, offset: 0x02b8 = 696
FAT16: ret: 0x000002b9, entry: 0x000002b8, offset: 0x02b8
FAT16: entry: 0x000002b9 = 697, offset: 0x02b9 = 697
FAT16: ret: 0x000002ba, entry: 0x000002b9, offset: 0x02b9
FAT16: entry: 0x000002ba = 698, offset: 0x02ba = 698
FAT16: ret: 0x000002bb, entry: 0x000002ba, offset: 0x02ba
FAT16: entry: 0x000002bb = 699, offset: 0x02bb = 699
FAT16: ret: 0x000002bc, entry: 0x000002bb, offset: 0x02bb
FAT16: entry: 0x000002bc = 700, offset: 0x02bc = 700
FAT16: ret: 0x000002bd, entry: 0x000002bc, offset: 0x02bc
FAT16: entry: 0x000002bd = 701, offset: 0x02bd = 701
FAT16: ret: 0x000002be, entry: 0x000002bd, offset: 0x02bd
FAT16: entry: 0x000002be = 702, offset: 0x02be = 702
FAT16: ret: 0x000002bf, entry: 0x000002be, offset: 0x02be
FAT16: entry: 0x000002bf = 703, offset: 0x02bf = 703
FAT16: ret: 0x000002c0, entry: 0x000002bf, offset: 0x02bf
FAT16: entry: 0x000002c0 = 704, offset: 0x02c0 = 704
FAT16: ret: 0x000002c1, entry: 0x000002c0, offset: 0x02c0
FAT16: entry: 0x000002c1 = 705, offset: 0x02c1 = 705
FAT16: ret: 0x000002c2, entry: 0x000002c1, offset: 0x02c1
FAT16: entry: 0x000002c2 = 706, offset: 0x02c2 = 706
FAT16: ret: 0x000002c3, entry: 0x000002c2, offset: 0x02c2
FAT16: entry: 0x000002c3 = 707, offset: 0x02c3 = 707
FAT16: ret: 0x000002c4, entry: 0x000002c3, offset: 0x02c3
FAT16: entry: 0x000002c4 = 708, offset: 0x02c4 = 708
FAT16: ret: 0x000002c5, entry: 0x000002c4, offset: 0x02c4
FAT16: entry: 0x000002c5 = 709, offset: 0x02c5 = 709
FAT16: ret: 0x000002c6, entry: 0x000002c5, offset: 0x02c5
FAT16: entry: 0x000002c6 = 710, offset: 0x02c6 = 710
FAT16: ret: 0x000002c7, entry: 0x000002c6, offset: 0x02c6
FAT16: entry: 0x000002c7 = 711, offset: 0x02c7 = 711
FAT16: ret: 0x000002c8, entry: 0x000002c7, offset: 0x02c7
FAT16: entry: 0x000002c8 = 712, offset: 0x02c8 = 712
FAT16: ret: 0x000002c9, entry: 0x000002c8, offset: 0x02c8
FAT16: entry: 0x000002c9 = 713, offset: 0x02c9 = 713
FAT16: ret: 0x000002ca, entry: 0x000002c9, offset: 0x02c9
FAT16: entry: 0x000002ca = 714, offset: 0x02ca = 714
FAT16: ret: 0x000002cb, entry: 0x000002ca, offset: 0x02ca
FAT16: entry: 0x000002cb = 715, offset: 0x02cb = 715
FAT16: ret: 0x000002cc, entry: 0x000002cb, offset: 0x02cb
FAT16: entry: 0x000002cc = 716, offset: 0x02cc = 716
FAT16: ret: 0x000002cd, entry: 0x000002cc, offset: 0x02cc
FAT16: entry: 0x000002cd = 717, offset: 0x02cd = 717
FAT16: ret: 0x000002ce, entry: 0x000002cd, offset: 0x02cd
FAT16: entry: 0x000002ce = 718, offset: 0x02ce = 718
FAT16: ret: 0x000002ef, entry: 0x000002ce, offset: 0x02ce
gc - clustnum: 525, startsect: 2525
FAT16: entry: 0x000002ce = 718, offset: 0x02ce = 718
FAT16: ret: 0x000002ef, entry: 0x000002ce, offset: 0x02ce
FAT16: entry: 0x000002ef = 751, offset: 0x02ef = 751
FAT16: ret: 0x000002f0, entry: 0x000002ef, offset: 0x02ef
FAT16: entry: 0x000002f0 = 752, offset: 0x02f0 = 752
FAT16: ret: 0x000002f1, entry: 0x000002f0, offset: 0x02f0
FAT16: entry: 0x000002f1 = 753, offset: 0x02f1 = 753
FAT16: ret: 0x000002f2, entry: 0x000002f1, offset: 0x02f1
FAT16: entry: 0x000002f2 = 754, offset: 0x02f2 = 754
FAT16: ret: 0x000002f3, entry: 0x000002f2, offset: 0x02f2
FAT16: entry: 0x000002f3 = 755, offset: 0x02f3 = 755
FAT16: ret: 0x000002f4, entry: 0x000002f3, offset: 0x02f3
FAT16: entry: 0x000002f4 = 756, offset: 0x02f4 = 756
FAT16: ret: 0x000002f5, entry: 0x000002f4, offset: 0x02f4
FAT16: entry: 0x000002f5 = 757, offset: 0x02f5 = 757
FAT16: ret: 0x000002f6, entry: 0x000002f5, offset: 0x02f5
FAT16: entry: 0x000002f6 = 758, offset: 0x02f6 = 758
FAT16: ret: 0x000002f7, entry: 0x000002f6, offset: 0x02f6
FAT16: entry: 0x000002f7 = 759, offset: 0x02f7 = 759
FAT16: ret: 0x000002f8, entry: 0x000002f7, offset: 0x02f7
FAT16: entry: 0x000002f8 = 760, offset: 0x02f8 = 760
FAT16: ret: 0x000002f9, entry: 0x000002f8, offset: 0x02f8
FAT16: entry: 0x000002f9 = 761, offset: 0x02f9 = 761
FAT16: ret: 0x000002fa, entry: 0x000002f9, offset: 0x02f9
FAT16: entry: 0x000002fa = 762, offset: 0x02fa = 762
FAT16: ret: 0x000002fb, entry: 0x000002fa, offset: 0x02fa
FAT16: entry: 0x000002fb = 763, offset: 0x02fb = 763
FAT16: ret: 0x000002fc, entry: 0x000002fb, offset: 0x02fb
FAT16: entry: 0x000002fc = 764, offset: 0x02fc = 764
FAT16: ret: 0x000002fd, entry: 0x000002fc, offset: 0x02fc
FAT16: entry: 0x000002fd = 765, offset: 0x02fd = 765
FAT16: ret: 0x000002fe, entry: 0x000002fd, offset: 0x02fd
FAT16: entry: 0x000002fe = 766, offset: 0x02fe = 766
FAT16: ret: 0x000002ff, entry: 0x000002fe, offset: 0x02fe
FAT16: entry: 0x000002ff = 767, offset: 0x02ff = 767
FAT16: ret: 0x00000300, entry: 0x000002ff, offset: 0x02ff
FAT16: entry: 0x00000300 = 768, offset: 0x0300 = 768
FAT16: ret: 0x00000301, entry: 0x00000300, offset: 0x0300
FAT16: entry: 0x00000301 = 769, offset: 0x0301 = 769
FAT16: ret: 0x00000302, entry: 0x00000301, offset: 0x0301
FAT16: entry: 0x00000302 = 770, offset: 0x0302 = 770
FAT16: ret: 0x00000303, entry: 0x00000302, offset: 0x0302
FAT16: entry: 0x00000303 = 771, offset: 0x0303 = 771
FAT16: ret: 0x00000304, entry: 0x00000303, offset: 0x0303
FAT16: entry: 0x00000304 = 772, offset: 0x0304 = 772
FAT16: ret: 0x00000305, entry: 0x00000304, offset: 0x0304
FAT16: entry: 0x00000305 = 773, offset: 0x0305 = 773
FAT16: ret: 0x00000306, entry: 0x00000305, offset: 0x0305
FAT16: entry: 0x00000306 = 774, offset: 0x0306 = 774
FAT16: ret: 0x00000307, entry: 0x00000306, offset: 0x0306
FAT16: entry: 0x00000307 = 775, offset: 0x0307 = 775
FAT16: ret: 0x00000308, entry: 0x00000307, offset: 0x0307
FAT16: entry: 0x00000308 = 776, offset: 0x0308 = 776
FAT16: ret: 0x00000309, entry: 0x00000308, offset: 0x0308
FAT16: entry: 0x00000309 = 777, offset: 0x0309 = 777
FAT16: ret: 0x0000030a, entry: 0x00000309, offset: 0x0309
FAT16: entry: 0x0000030a = 778, offset: 0x030a = 778
FAT16: ret: 0x0000030b, entry: 0x0000030a, offset: 0x030a
FAT16: entry: 0x0000030b = 779, offset: 0x030b = 779
FAT16: ret: 0x0000030c, entry: 0x0000030b, offset: 0x030b
FAT16: entry: 0x0000030c = 780, offset: 0x030c = 780
FAT16: ret: 0x0000030d, entry: 0x0000030c, offset: 0x030c
FAT16: entry: 0x0000030d = 781, offset: 0x030d = 781
FAT16: ret: 0x0000030e, entry: 0x0000030d, offset: 0x030d
FAT16: entry: 0x0000030e = 782, offset: 0x030e = 782
FAT16: ret: 0x0000030f, entry: 0x0000030e, offset: 0x030e
FAT16: entry: 0x0000030f = 783, offset: 0x030f = 783
FAT16: ret: 0x00000310, entry: 0x0000030f, offset: 0x030f
FAT16: entry: 0x00000310 = 784, offset: 0x0310 = 784
FAT16: ret: 0x00000311, entry: 0x00000310, offset: 0x0310
FAT16: entry: 0x00000311 = 785, offset: 0x0311 = 785
FAT16: ret: 0x00000312, entry: 0x00000311, offset: 0x0311
FAT16: entry: 0x00000312 = 786, offset: 0x0312 = 786
FAT16: ret: 0x00000313, entry: 0x00000312, offset: 0x0312
FAT16: entry: 0x00000313 = 787, offset: 0x0313 = 787
FAT16: ret: 0x00000314, entry: 0x00000313, offset: 0x0313
FAT16: entry: 0x00000314 = 788, offset: 0x0314 = 788
FAT16: ret: 0x00000315, entry: 0x00000314, offset: 0x0314
FAT16: entry: 0x00000315 = 789, offset: 0x0315 = 789
FAT16: ret: 0x00000316, entry: 0x00000315, offset: 0x0315
FAT16: entry: 0x00000316 = 790, offset: 0x0316 = 790
FAT16: ret: 0x00000317, entry: 0x00000316, offset: 0x0316
FAT16: entry: 0x00000317 = 791, offset: 0x0317 = 791
FAT16: ret: 0x00000318, entry: 0x00000317, offset: 0x0317
FAT16: entry: 0x00000318 = 792, offset: 0x0318 = 792
FAT16: ret: 0x00000319, entry: 0x00000318, offset: 0x0318
FAT16: entry: 0x00000319 = 793, offset: 0x0319 = 793
FAT16: ret: 0x0000031a, entry: 0x00000319, offset: 0x0319
FAT16: entry: 0x0000031a = 794, offset: 0x031a = 794
FAT16: ret: 0x0000031b, entry: 0x0000031a, offset: 0x031a
FAT16: entry: 0x0000031b = 795, offset: 0x031b = 795
FAT16: ret: 0x0000031c, entry: 0x0000031b, offset: 0x031b
FAT16: entry: 0x0000031c = 796, offset: 0x031c = 796
FAT16: ret: 0x0000031d, entry: 0x0000031c, offset: 0x031c
FAT16: entry: 0x0000031d = 797, offset: 0x031d = 797
FAT16: ret: 0x0000031e, entry: 0x0000031d, offset: 0x031d
FAT16: entry: 0x0000031e = 798, offset: 0x031e = 798
FAT16: ret: 0x0000031f, entry: 0x0000031e, offset: 0x031e
FAT16: entry: 0x0000031f = 799, offset: 0x031f = 799
FAT16: ret: 0x00000320, entry: 0x0000031f, offset: 0x031f
FAT16: entry: 0x00000320 = 800, offset: 0x0320 = 800
FAT16: ret: 0x00000321, entry: 0x00000320, offset: 0x0320
FAT16: entry: 0x00000321 = 801, offset: 0x0321 = 801
FAT16: ret: 0x00000322, entry: 0x00000321, offset: 0x0321
FAT16: entry: 0x00000322 = 802, offset: 0x0322 = 802
FAT16: ret: 0x00000323, entry: 0x00000322, offset: 0x0322
FAT16: entry: 0x00000323 = 803, offset: 0x0323 = 803
FAT16: ret: 0x00000324, entry: 0x00000323, offset: 0x0323
FAT16: entry: 0x00000324 = 804, offset: 0x0324 = 804
FAT16: ret: 0x00000325, entry: 0x00000324, offset: 0x0324
FAT16: entry: 0x00000325 = 805, offset: 0x0325 = 805
FAT16: ret: 0x00000326, entry: 0x00000325, offset: 0x0325
FAT16: entry: 0x00000326 = 806, offset: 0x0326 = 806
FAT16: ret: 0x00000327, entry: 0x00000326, offset: 0x0326
FAT16: entry: 0x00000327 = 807, offset: 0x0327 = 807
FAT16: ret: 0x00000328, entry: 0x00000327, offset: 0x0327
FAT16: entry: 0x00000328 = 808, offset: 0x0328 = 808
FAT16: ret: 0x00000329, entry: 0x00000328, offset: 0x0328
FAT16: entry: 0x00000329 = 809, offset: 0x0329 = 809
FAT16: ret: 0x0000032a, entry: 0x00000329, offset: 0x0329
FAT16: entry: 0x0000032a = 810, offset: 0x032a = 810
FAT16: ret: 0x0000032b, entry: 0x0000032a, offset: 0x032a
FAT16: entry: 0x0000032b = 811, offset: 0x032b = 811
FAT16: ret: 0x0000032c, entry: 0x0000032b, offset: 0x032b
FAT16: entry: 0x0000032c = 812, offset: 0x032c = 812
FAT16: ret: 0x0000032d, entry: 0x0000032c, offset: 0x032c
FAT16: entry: 0x0000032d = 813, offset: 0x032d = 813
FAT16: ret: 0x0000032e, entry: 0x0000032d, offset: 0x032d
FAT16: entry: 0x0000032e = 814, offset: 0x032e = 814
FAT16: ret: 0x0000032f, entry: 0x0000032e, offset: 0x032e
FAT16: entry: 0x0000032f = 815, offset: 0x032f = 815
FAT16: ret: 0x00000330, entry: 0x0000032f, offset: 0x032f
FAT16: entry: 0x00000330 = 816, offset: 0x0330 = 816
FAT16: ret: 0x00000331, entry: 0x00000330, offset: 0x0330
FAT16: entry: 0x00000331 = 817, offset: 0x0331 = 817
FAT16: ret: 0x00000332, entry: 0x00000331, offset: 0x0331
FAT16: entry: 0x00000332 = 818, offset: 0x0332 = 818
FAT16: ret: 0x00000333, entry: 0x00000332, offset: 0x0332
FAT16: entry: 0x00000333 = 819, offset: 0x0333 = 819
FAT16: ret: 0x00000334, entry: 0x00000333, offset: 0x0333
FAT16: entry: 0x00000334 = 820, offset: 0x0334 = 820
FAT16: ret: 0x00000335, entry: 0x00000334, offset: 0x0334
FAT16: entry: 0x00000335 = 821, offset: 0x0335 = 821
FAT16: ret: 0x00000336, entry: 0x00000335, offset: 0x0335
FAT16: entry: 0x00000336 = 822, offset: 0x0336 = 822
FAT16: ret: 0x00000337, entry: 0x00000336, offset: 0x0336
FAT16: entry: 0x00000337 = 823, offset: 0x0337 = 823
FAT16: ret: 0x00000338, entry: 0x00000337, offset: 0x0337
FAT16: entry: 0x00000338 = 824, offset: 0x0338 = 824
FAT16: ret: 0x00000339, entry: 0x00000338, offset: 0x0338
FAT16: entry: 0x00000339 = 825, offset: 0x0339 = 825
FAT16: ret: 0x0000033a, entry: 0x00000339, offset: 0x0339
FAT16: entry: 0x0000033a = 826, offset: 0x033a = 826
FAT16: ret: 0x0000033b, entry: 0x0000033a, offset: 0x033a
FAT16: entry: 0x0000033b = 827, offset: 0x033b = 827
FAT16: ret: 0x0000033c, entry: 0x0000033b, offset: 0x033b
FAT16: entry: 0x0000033c = 828, offset: 0x033c = 828
FAT16: ret: 0x0000033d, entry: 0x0000033c, offset: 0x033c
FAT16: entry: 0x0000033d = 829, offset: 0x033d = 829
FAT16: ret: 0x0000033e, entry: 0x0000033d, offset: 0x033d
FAT16: entry: 0x0000033e = 830, offset: 0x033e = 830
FAT16: ret: 0x0000033f, entry: 0x0000033e, offset: 0x033e
FAT16: entry: 0x0000033f = 831, offset: 0x033f = 831
FAT16: ret: 0x00000340, entry: 0x0000033f, offset: 0x033f
FAT16: entry: 0x00000340 = 832, offset: 0x0340 = 832
FAT16: ret: 0x00000341, entry: 0x00000340, offset: 0x0340
FAT16: entry: 0x00000341 = 833, offset: 0x0341 = 833
FAT16: ret: 0x00000342, entry: 0x00000341, offset: 0x0341
FAT16: entry: 0x00000342 = 834, offset: 0x0342 = 834
FAT16: ret: 0x00000343, entry: 0x00000342, offset: 0x0342
FAT16: entry: 0x00000343 = 835, offset: 0x0343 = 835
FAT16: ret: 0x00000344, entry: 0x00000343, offset: 0x0343
FAT16: entry: 0x00000344 = 836, offset: 0x0344 = 836
FAT16: ret: 0x00000345, entry: 0x00000344, offset: 0x0344
FAT16: entry: 0x00000345 = 837, offset: 0x0345 = 837
FAT16: ret: 0x00000346, entry: 0x00000345, offset: 0x0345
FAT16: entry: 0x00000346 = 838, offset: 0x0346 = 838
FAT16: ret: 0x00000347, entry: 0x00000346, offset: 0x0346
FAT16: entry: 0x00000347 = 839, offset: 0x0347 = 839
FAT16: ret: 0x00000348, entry: 0x00000347, offset: 0x0347
FAT16: entry: 0x00000348 = 840, offset: 0x0348 = 840
FAT16: ret: 0x00000349, entry: 0x00000348, offset: 0x0348
FAT16: entry: 0x00000349 = 841, offset: 0x0349 = 841
FAT16: ret: 0x0000034a, entry: 0x00000349, offset: 0x0349
FAT16: entry: 0x0000034a = 842, offset: 0x034a = 842
FAT16: ret: 0x0000034b, entry: 0x0000034a, offset: 0x034a
FAT16: entry: 0x0000034b = 843, offset: 0x034b = 843
FAT16: ret: 0x0000034c, entry: 0x0000034b, offset: 0x034b
FAT16: entry: 0x0000034c = 844, offset: 0x034c = 844
FAT16: ret: 0x0000034d, entry: 0x0000034c, offset: 0x034c
FAT16: entry: 0x0000034d = 845, offset: 0x034d = 845
FAT16: ret: 0x0000034e, entry: 0x0000034d, offset: 0x034d
FAT16: entry: 0x0000034e = 846, offset: 0x034e = 846
FAT16: ret: 0x0000034f, entry: 0x0000034e, offset: 0x034e
FAT16: entry: 0x0000034f = 847, offset: 0x034f = 847
FAT16: ret: 0x00000350, entry: 0x0000034f, offset: 0x034f
FAT16: entry: 0x00000350 = 848, offset: 0x0350 = 848
FAT16: ret: 0x00000351, entry: 0x00000350, offset: 0x0350
FAT16: entry: 0x00000351 = 849, offset: 0x0351 = 849
FAT16: ret: 0x00000352, entry: 0x00000351, offset: 0x0351
FAT16: entry: 0x00000352 = 850, offset: 0x0352 = 850
FAT16: ret: 0x00000353, entry: 0x00000352, offset: 0x0352
FAT16: entry: 0x00000353 = 851, offset: 0x0353 = 851
FAT16: ret: 0x00000354, entry: 0x00000353, offset: 0x0353
FAT16: entry: 0x00000354 = 852, offset: 0x0354 = 852
FAT16: ret: 0x00000355, entry: 0x00000354, offset: 0x0354
FAT16: entry: 0x00000355 = 853, offset: 0x0355 = 853
FAT16: ret: 0x00000356, entry: 0x00000355, offset: 0x0355
FAT16: entry: 0x00000356 = 854, offset: 0x0356 = 854
FAT16: ret: 0x00000357, entry: 0x00000356, offset: 0x0356
FAT16: entry: 0x00000357 = 855, offset: 0x0357 = 855
FAT16: ret: 0x00000358, entry: 0x00000357, offset: 0x0357
FAT16: entry: 0x00000358 = 856, offset: 0x0358 = 856
FAT16: ret: 0x00000359, entry: 0x00000358, offset: 0x0358
FAT16: entry: 0x00000359 = 857, offset: 0x0359 = 857
FAT16: ret: 0x0000035a, entry: 0x00000359, offset: 0x0359
FAT16: entry: 0x0000035a = 858, offset: 0x035a = 858
FAT16: ret: 0x0000035b, entry: 0x0000035a, offset: 0x035a
FAT16: entry: 0x0000035b = 859, offset: 0x035b = 859
FAT16: ret: 0x0000035c, entry: 0x0000035b, offset: 0x035b
FAT16: entry: 0x0000035c = 860, offset: 0x035c = 860
FAT16: ret: 0x0000035d, entry: 0x0000035c, offset: 0x035c
FAT16: entry: 0x0000035d = 861, offset: 0x035d = 861
FAT16: ret: 0x0000035e, entry: 0x0000035d, offset: 0x035d
FAT16: entry: 0x0000035e = 862, offset: 0x035e = 862
FAT16: ret: 0x0000035f, entry: 0x0000035e, offset: 0x035e
FAT16: entry: 0x0000035f = 863, offset: 0x035f = 863
FAT16: ret: 0x00000360, entry: 0x0000035f, offset: 0x035f
FAT16: entry: 0x00000360 = 864, offset: 0x0360 = 864
FAT16: ret: 0x00000361, entry: 0x00000360, offset: 0x0360
FAT16: entry: 0x00000361 = 865, offset: 0x0361 = 865
FAT16: ret: 0x00000362, entry: 0x00000361, offset: 0x0361
FAT16: entry: 0x00000362 = 866, offset: 0x0362 = 866
FAT16: ret: 0x00000363, entry: 0x00000362, offset: 0x0362
FAT16: entry: 0x00000363 = 867, offset: 0x0363 = 867
FAT16: ret: 0x00000364, entry: 0x00000363, offset: 0x0363
FAT16: entry: 0x00000364 = 868, offset: 0x0364 = 868
FAT16: ret: 0x00000365, entry: 0x00000364, offset: 0x0364
FAT16: entry: 0x00000365 = 869, offset: 0x0365 = 869
FAT16: ret: 0x00000366, entry: 0x00000365, offset: 0x0365
FAT16: entry: 0x00000366 = 870, offset: 0x0366 = 870
FAT16: ret: 0x00000367, entry: 0x00000366, offset: 0x0366
FAT16: entry: 0x00000367 = 871, offset: 0x0367 = 871
FAT16: ret: 0x00000368, entry: 0x00000367, offset: 0x0367
FAT16: entry: 0x00000368 = 872, offset: 0x0368 = 872
FAT16: ret: 0x00000369, entry: 0x00000368, offset: 0x0368
FAT16: entry: 0x00000369 = 873, offset: 0x0369 = 873
FAT16: ret: 0x0000036a, entry: 0x00000369, offset: 0x0369
FAT16: entry: 0x0000036a = 874, offset: 0x036a = 874
FAT16: ret: 0x0000036b, entry: 0x0000036a, offset: 0x036a
FAT16: entry: 0x0000036b = 875, offset: 0x036b = 875
FAT16: ret: 0x0000036c, entry: 0x0000036b, offset: 0x036b
FAT16: entry: 0x0000036c = 876, offset: 0x036c = 876
FAT16: ret: 0x0000036d, entry: 0x0000036c, offset: 0x036c
FAT16: entry: 0x0000036d = 877, offset: 0x036d = 877
FAT16: ret: 0x0000036e, entry: 0x0000036d, offset: 0x036d
FAT16: entry: 0x0000036e = 878, offset: 0x036e = 878
FAT16: ret: 0x0000036f, entry: 0x0000036e, offset: 0x036e
FAT16: entry: 0x0000036f = 879, offset: 0x036f = 879
FAT16: ret: 0x00000370, entry: 0x0000036f, offset: 0x036f
FAT16: entry: 0x00000370 = 880, offset: 0x0370 = 880
FAT16: ret: 0x00000371, entry: 0x00000370, offset: 0x0370
FAT16: entry: 0x00000371 = 881, offset: 0x0371 = 881
FAT16: ret: 0x00000372, entry: 0x00000371, offset: 0x0371
FAT16: entry: 0x00000372 = 882, offset: 0x0372 = 882
FAT16: ret: 0x00000373, entry: 0x00000372, offset: 0x0372
FAT16: entry: 0x00000373 = 883, offset: 0x0373 = 883
FAT16: ret: 0x00000374, entry: 0x00000373, offset: 0x0373
FAT16: entry: 0x00000374 = 884, offset: 0x0374 = 884
FAT16: ret: 0x00000375, entry: 0x00000374, offset: 0x0374
FAT16: entry: 0x00000375 = 885, offset: 0x0375 = 885
FAT16: ret: 0x00000376, entry: 0x00000375, offset: 0x0375
FAT16: entry: 0x00000376 = 886, offset: 0x0376 = 886
FAT16: ret: 0x00000377, entry: 0x00000376, offset: 0x0376
FAT16: entry: 0x00000377 = 887, offset: 0x0377 = 887
FAT16: ret: 0x00000378, entry: 0x00000377, offset: 0x0377
FAT16: entry: 0x00000378 = 888, offset: 0x0378 = 888
FAT16: ret: 0x00000379, entry: 0x00000378, offset: 0x0378
FAT16: entry: 0x00000379 = 889, offset: 0x0379 = 889
FAT16: ret: 0x0000037a, entry: 0x00000379, offset: 0x0379
FAT16: entry: 0x0000037a = 890, offset: 0x037a = 890
FAT16: ret: 0x0000037b, entry: 0x0000037a, offset: 0x037a
FAT16: entry: 0x0000037b = 891, offset: 0x037b = 891
FAT16: ret: 0x0000037c, entry: 0x0000037b, offset: 0x037b
FAT16: entry: 0x0000037c = 892, offset: 0x037c = 892
FAT16: ret: 0x0000037d, entry: 0x0000037c, offset: 0x037c
FAT16: entry: 0x0000037d = 893, offset: 0x037d = 893
FAT16: ret: 0x0000037e, entry: 0x0000037d, offset: 0x037d
FAT16: entry: 0x0000037e = 894, offset: 0x037e = 894
FAT16: ret: 0x0000037f, entry: 0x0000037e, offset: 0x037e
FAT16: entry: 0x0000037f = 895, offset: 0x037f = 895
FAT16: ret: 0x00000380, entry: 0x0000037f, offset: 0x037f
FAT16: entry: 0x00000380 = 896, offset: 0x0380 = 896
FAT16: ret: 0x00000381, entry: 0x00000380, offset: 0x0380
FAT16: entry: 0x00000381 = 897, offset: 0x0381 = 897
FAT16: ret: 0x00000382, entry: 0x00000381, offset: 0x0381
FAT16: entry: 0x00000382 = 898, offset: 0x0382 = 898
FAT16: ret: 0x00000383, entry: 0x00000382, offset: 0x0382
FAT16: entry: 0x00000383 = 899, offset: 0x0383 = 899
FAT16: ret: 0x00000384, entry: 0x00000383, offset: 0x0383
FAT16: entry: 0x00000384 = 900, offset: 0x0384 = 900
FAT16: ret: 0x00000385, entry: 0x00000384, offset: 0x0384
FAT16: entry: 0x00000385 = 901, offset: 0x0385 = 901
FAT16: ret: 0x00000386, entry: 0x00000385, offset: 0x0385
FAT16: entry: 0x00000386 = 902, offset: 0x0386 = 902
FAT16: ret: 0x00000387, entry: 0x00000386, offset: 0x0386
FAT16: entry: 0x00000387 = 903, offset: 0x0387 = 903
FAT16: ret: 0x00000388, entry: 0x00000387, offset: 0x0387
FAT16: entry: 0x00000388 = 904, offset: 0x0388 = 904
FAT16: ret: 0x00000389, entry: 0x00000388, offset: 0x0388
FAT16: entry: 0x00000389 = 905, offset: 0x0389 = 905
FAT16: ret: 0x0000038a, entry: 0x00000389, offset: 0x0389
FAT16: entry: 0x0000038a = 906, offset: 0x038a = 906
FAT16: ret: 0x0000038b, entry: 0x0000038a, offset: 0x038a
FAT16: entry: 0x0000038b = 907, offset: 0x038b = 907
FAT16: ret: 0x0000038c, entry: 0x0000038b, offset: 0x038b
FAT16: entry: 0x0000038c = 908, offset: 0x038c = 908
FAT16: ret: 0x0000038d, entry: 0x0000038c, offset: 0x038c
FAT16: entry: 0x0000038d = 909, offset: 0x038d = 909
FAT16: ret: 0x0000038e, entry: 0x0000038d, offset: 0x038d
FAT16: entry: 0x0000038e = 910, offset: 0x038e = 910
FAT16: ret: 0x0000038f, entry: 0x0000038e, offset: 0x038e
FAT16: entry: 0x0000038f = 911, offset: 0x038f = 911
FAT16: ret: 0x00000390, entry: 0x0000038f, offset: 0x038f
FAT16: entry: 0x00000390 = 912, offset: 0x0390 = 912
FAT16: ret: 0x00000391, entry: 0x00000390, offset: 0x0390
FAT16: entry: 0x00000391 = 913, offset: 0x0391 = 913
FAT16: ret: 0x00000392, entry: 0x00000391, offset: 0x0391
FAT16: entry: 0x00000392 = 914, offset: 0x0392 = 914
FAT16: ret: 0x00000393, entry: 0x00000392, offset: 0x0392
FAT16: entry: 0x00000393 = 915, offset: 0x0393 = 915
FAT16: ret: 0x00000394, entry: 0x00000393, offset: 0x0393
FAT16: entry: 0x00000394 = 916, offset: 0x0394 = 916
FAT16: ret: 0x00000395, entry: 0x00000394, offset: 0x0394
FAT16: entry: 0x00000395 = 917, offset: 0x0395 = 917
FAT16: ret: 0x00000396, entry: 0x00000395, offset: 0x0395
FAT16: entry: 0x00000396 = 918, offset: 0x0396 = 918
FAT16: ret: 0x00000397, entry: 0x00000396, offset: 0x0396
FAT16: entry: 0x00000397 = 919, offset: 0x0397 = 919
FAT16: ret: 0x00000398, entry: 0x00000397, offset: 0x0397
FAT16: entry: 0x00000398 = 920, offset: 0x0398 = 920
FAT16: ret: 0x00000399, entry: 0x00000398, offset: 0x0398
FAT16: entry: 0x00000399 = 921, offset: 0x0399 = 921
FAT16: ret: 0x0000039a, entry: 0x00000399, offset: 0x0399
FAT16: entry: 0x0000039a = 922, offset: 0x039a = 922
FAT16: ret: 0x0000039b, entry: 0x0000039a, offset: 0x039a
FAT16: entry: 0x0000039b = 923, offset: 0x039b = 923
FAT16: ret: 0x0000039c, entry: 0x0000039b, offset: 0x039b
FAT16: entry: 0x0000039c = 924, offset: 0x039c = 924
FAT16: ret: 0x0000039d, entry: 0x0000039c, offset: 0x039c
FAT16: entry: 0x0000039d = 925, offset: 0x039d = 925
FAT16: ret: 0x0000039e, entry: 0x0000039d, offset: 0x039d
FAT16: entry: 0x0000039e = 926, offset: 0x039e = 926
FAT16: ret: 0x0000039f, entry: 0x0000039e, offset: 0x039e
FAT16: entry: 0x0000039f = 927, offset: 0x039f = 927
FAT16: ret: 0x000003a0, entry: 0x0000039f, offset: 0x039f
FAT16: entry: 0x000003a0 = 928, offset: 0x03a0 = 928
FAT16: ret: 0x000003a1, entry: 0x000003a0, offset: 0x03a0
FAT16: entry: 0x000003a1 = 929, offset: 0x03a1 = 929
FAT16: ret: 0x000003a2, entry: 0x000003a1, offset: 0x03a1
FAT16: entry: 0x000003a2 = 930, offset: 0x03a2 = 930
FAT16: ret: 0x000003a3, entry: 0x000003a2, offset: 0x03a2
FAT16: entry: 0x000003a3 = 931, offset: 0x03a3 = 931
FAT16: ret: 0x000003a4, entry: 0x000003a3, offset: 0x03a3
FAT16: entry: 0x000003a4 = 932, offset: 0x03a4 = 932
FAT16: ret: 0x000003a5, entry: 0x000003a4, offset: 0x03a4
FAT16: entry: 0x000003a5 = 933, offset: 0x03a5 = 933
FAT16: ret: 0x000003a6, entry: 0x000003a5, offset: 0x03a5
FAT16: entry: 0x000003a6 = 934, offset: 0x03a6 = 934
FAT16: ret: 0x000003a7, entry: 0x000003a6, offset: 0x03a6
FAT16: entry: 0x000003a7 = 935, offset: 0x03a7 = 935
FAT16: ret: 0x000003a8, entry: 0x000003a7, offset: 0x03a7
FAT16: entry: 0x000003a8 = 936, offset: 0x03a8 = 936
FAT16: ret: 0x000003a9, entry: 0x000003a8, offset: 0x03a8
FAT16: entry: 0x000003a9 = 937, offset: 0x03a9 = 937
FAT16: ret: 0x000003aa, entry: 0x000003a9, offset: 0x03a9
FAT16: entry: 0x000003aa = 938, offset: 0x03aa = 938
FAT16: ret: 0x000003ab, entry: 0x000003aa, offset: 0x03aa
FAT16: entry: 0x000003ab = 939, offset: 0x03ab = 939
FAT16: ret: 0x000003ac, entry: 0x000003ab, offset: 0x03ab
FAT16: entry: 0x000003ac = 940, offset: 0x03ac = 940
FAT16: ret: 0x000003ad, entry: 0x000003ac, offset: 0x03ac
FAT16: entry: 0x000003ad = 941, offset: 0x03ad = 941
FAT16: ret: 0x000003ae, entry: 0x000003ad, offset: 0x03ad
FAT16: entry: 0x000003ae = 942, offset: 0x03ae = 942
FAT16: ret: 0x000003af, entry: 0x000003ae, offset: 0x03ae
FAT16: entry: 0x000003af = 943, offset: 0x03af = 943
FAT16: ret: 0x000003b0, entry: 0x000003af, offset: 0x03af
FAT16: entry: 0x000003b0 = 944, offset: 0x03b0 = 944
FAT16: ret: 0x000003b1, entry: 0x000003b0, offset: 0x03b0
FAT16: entry: 0x000003b1 = 945, offset: 0x03b1 = 945
FAT16: ret: 0x000003b2, entry: 0x000003b1, offset: 0x03b1
FAT16: entry: 0x000003b2 = 946, offset: 0x03b2 = 946
FAT16: ret: 0x000003b3, entry: 0x000003b2, offset: 0x03b2
FAT16: entry: 0x000003b3 = 947, offset: 0x03b3 = 947
FAT16: ret: 0x000003b4, entry: 0x000003b3, offset: 0x03b3
FAT16: entry: 0x000003b4 = 948, offset: 0x03b4 = 948
FAT16: ret: 0x000003b5, entry: 0x000003b4, offset: 0x03b4
FAT16: entry: 0x000003b5 = 949, offset: 0x03b5 = 949
FAT16: ret: 0x000003b6, entry: 0x000003b5, offset: 0x03b5
FAT16: entry: 0x000003b6 = 950, offset: 0x03b6 = 950
FAT16: ret: 0x000003b7, entry: 0x000003b6, offset: 0x03b6
FAT16: entry: 0x000003b7 = 951, offset: 0x03b7 = 951
FAT16: ret: 0x000003b8, entry: 0x000003b7, offset: 0x03b7
FAT16: entry: 0x000003b8 = 952, offset: 0x03b8 = 952
FAT16: ret: 0x000003b9, entry: 0x000003b8, offset: 0x03b8
FAT16: entry: 0x000003b9 = 953, offset: 0x03b9 = 953
FAT16: ret: 0x000003ba, entry: 0x000003b9, offset: 0x03b9
FAT16: entry: 0x000003ba = 954, offset: 0x03ba = 954
FAT16: ret: 0x000003bb, entry: 0x000003ba, offset: 0x03ba
FAT16: entry: 0x000003bb = 955, offset: 0x03bb = 955
FAT16: ret: 0x000003bc, entry: 0x000003bb, offset: 0x03bb
FAT16: entry: 0x000003bc = 956, offset: 0x03bc = 956
FAT16: ret: 0x000003bd, entry: 0x000003bc, offset: 0x03bc
FAT16: entry: 0x000003bd = 957, offset: 0x03bd = 957
FAT16: ret: 0x000003be, entry: 0x000003bd, offset: 0x03bd
FAT16: entry: 0x000003be = 958, offset: 0x03be = 958
FAT16: ret: 0x000003bf, entry: 0x000003be, offset: 0x03be
FAT16: entry: 0x000003bf = 959, offset: 0x03bf = 959
FAT16: ret: 0x000003c0, entry: 0x000003bf, offset: 0x03bf
FAT16: entry: 0x000003c0 = 960, offset: 0x03c0 = 960
FAT16: ret: 0x000003c1, entry: 0x000003c0, offset: 0x03c0
FAT16: entry: 0x000003c1 = 961, offset: 0x03c1 = 961
FAT16: ret: 0x000003c2, entry: 0x000003c1, offset: 0x03c1
FAT16: entry: 0x000003c2 = 962, offset: 0x03c2 = 962
FAT16: ret: 0x000003c3, entry: 0x000003c2, offset: 0x03c2
FAT16: entry: 0x000003c3 = 963, offset: 0x03c3 = 963
FAT16: ret: 0x000003c4, entry: 0x000003c3, offset: 0x03c3
FAT16: entry: 0x000003c4 = 964, offset: 0x03c4 = 964
FAT16: ret: 0x000003c5, entry: 0x000003c4, offset: 0x03c4
FAT16: entry: 0x000003c5 = 965, offset: 0x03c5 = 965
FAT16: ret: 0x000003c6, entry: 0x000003c5, offset: 0x03c5
FAT16: entry: 0x000003c6 = 966, offset: 0x03c6 = 966
FAT16: ret: 0x000003c7, entry: 0x000003c6, offset: 0x03c6
FAT16: entry: 0x000003c7 = 967, offset: 0x03c7 = 967
FAT16: ret: 0x000003c8, entry: 0x000003c7, offset: 0x03c7
FAT16: entry: 0x000003c8 = 968, offset: 0x03c8 = 968
FAT16: ret: 0x000003c9, entry: 0x000003c8, offset: 0x03c8
FAT16: entry: 0x000003c9 = 969, offset: 0x03c9 = 969
FAT16: ret: 0x000003ca, entry: 0x000003c9, offset: 0x03c9
FAT16: entry: 0x000003ca = 970, offset: 0x03ca = 970
FAT16: ret: 0x000003cb, entry: 0x000003ca, offset: 0x03ca
FAT16: entry: 0x000003cb = 971, offset: 0x03cb = 971
FAT16: ret: 0x000003cc, entry: 0x000003cb, offset: 0x03cb
FAT16: entry: 0x000003cc = 972, offset: 0x03cc = 972
FAT16: ret: 0x000003cd, entry: 0x000003cc, offset: 0x03cc
FAT16: entry: 0x000003cd = 973, offset: 0x03cd = 973
FAT16: ret: 0x000003ce, entry: 0x000003cd, offset: 0x03cd
FAT16: entry: 0x000003ce = 974, offset: 0x03ce = 974
FAT16: ret: 0x000003cf, entry: 0x000003ce, offset: 0x03ce
FAT16: entry: 0x000003cf = 975, offset: 0x03cf = 975
FAT16: ret: 0x000003d0, entry: 0x000003cf, offset: 0x03cf
FAT16: entry: 0x000003d0 = 976, offset: 0x03d0 = 976
FAT16: ret: 0x000003d1, entry: 0x000003d0, offset: 0x03d0
FAT16: entry: 0x000003d1 = 977, offset: 0x03d1 = 977
FAT16: ret: 0x000003d2, entry: 0x000003d1, offset: 0x03d1
FAT16: entry: 0x000003d2 = 978, offset: 0x03d2 = 978
FAT16: ret: 0x000003d3, entry: 0x000003d2, offset: 0x03d2
FAT16: entry: 0x000003d3 = 979, offset: 0x03d3 = 979
FAT16: ret: 0x000003d4, entry: 0x000003d3, offset: 0x03d3
FAT16: entry: 0x000003d4 = 980, offset: 0x03d4 = 980
FAT16: ret: 0x000003d5, entry: 0x000003d4, offset: 0x03d4
FAT16: entry: 0x000003d5 = 981, offset: 0x03d5 = 981
FAT16: ret: 0x000003d6, entry: 0x000003d5, offset: 0x03d5
FAT16: entry: 0x000003d6 = 982, offset: 0x03d6 = 982
FAT16: ret: 0x000003d7, entry: 0x000003d6, offset: 0x03d6
FAT16: entry: 0x000003d7 = 983, offset: 0x03d7 = 983
FAT16: ret: 0x000003d8, entry: 0x000003d7, offset: 0x03d7
FAT16: entry: 0x000003d8 = 984, offset: 0x03d8 = 984
FAT16: ret: 0x000003d9, entry: 0x000003d8, offset: 0x03d8
FAT16: entry: 0x000003d9 = 985, offset: 0x03d9 = 985
FAT16: ret: 0x000003da, entry: 0x000003d9, offset: 0x03d9
FAT16: entry: 0x000003da = 986, offset: 0x03da = 986
FAT16: ret: 0x000003db, entry: 0x000003da, offset: 0x03da
FAT16: entry: 0x000003db = 987, offset: 0x03db = 987
FAT16: ret: 0x000003dc, entry: 0x000003db, offset: 0x03db
FAT16: entry: 0x000003dc = 988, offset: 0x03dc = 988
FAT16: ret: 0x000003dd, entry: 0x000003dc, offset: 0x03dc
FAT16: entry: 0x000003dd = 989, offset: 0x03dd = 989
FAT16: ret: 0x000003de, entry: 0x000003dd, offset: 0x03dd
FAT16: entry: 0x000003de = 990, offset: 0x03de = 990
FAT16: ret: 0x000003df, entry: 0x000003de, offset: 0x03de
FAT16: entry: 0x000003df = 991, offset: 0x03df = 991
FAT16: ret: 0x000003e0, entry: 0x000003df, offset: 0x03df
FAT16: entry: 0x000003e0 = 992, offset: 0x03e0 = 992
FAT16: ret: 0x000003e1, entry: 0x000003e0, offset: 0x03e0
FAT16: entry: 0x000003e1 = 993, offset: 0x03e1 = 993
FAT16: ret: 0x000003e2, entry: 0x000003e1, offset: 0x03e1
FAT16: entry: 0x000003e2 = 994, offset: 0x03e2 = 994
FAT16: ret: 0x000003e3, entry: 0x000003e2, offset: 0x03e2
FAT16: entry: 0x000003e3 = 995, offset: 0x03e3 = 995
FAT16: ret: 0x000003e4, entry: 0x000003e3, offset: 0x03e3
FAT16: entry: 0x000003e4 = 996, offset: 0x03e4 = 996
FAT16: ret: 0x000003e5, entry: 0x000003e4, offset: 0x03e4
FAT16: entry: 0x000003e5 = 997, offset: 0x03e5 = 997
FAT16: ret: 0x000003e6, entry: 0x000003e5, offset: 0x03e5
FAT16: entry: 0x000003e6 = 998, offset: 0x03e6 = 998
FAT16: ret: 0x000003e7, entry: 0x000003e6, offset: 0x03e6
FAT16: entry: 0x000003e7 = 999, offset: 0x03e7 = 999
FAT16: ret: 0x000003e8, entry: 0x000003e7, offset: 0x03e7
FAT16: entry: 0x000003e8 = 1000, offset: 0x03e8 = 1000
FAT16: ret: 0x000003e9, entry: 0x000003e8, offset: 0x03e8
FAT16: entry: 0x000003e9 = 1001, offset: 0x03e9 = 1001
FAT16: ret: 0x000003ea, entry: 0x000003e9, offset: 0x03e9
FAT16: entry: 0x000003ea = 1002, offset: 0x03ea = 1002
FAT16: ret: 0x000003eb, entry: 0x000003ea, offset: 0x03ea
FAT16: entry: 0x000003eb = 1003, offset: 0x03eb = 1003
FAT16: ret: 0x000003ec, entry: 0x000003eb, offset: 0x03eb
FAT16: entry: 0x000003ec = 1004, offset: 0x03ec = 1004
FAT16: ret: 0x000003ed, entry: 0x000003ec, offset: 0x03ec
FAT16: entry: 0x000003ed = 1005, offset: 0x03ed = 1005
FAT16: ret: 0x000003ee, entry: 0x000003ed, offset: 0x03ed
FAT16: entry: 0x000003ee = 1006, offset: 0x03ee = 1006
FAT16: ret: 0x000003ef, entry: 0x000003ee, offset: 0x03ee
FAT16: entry: 0x000003ef = 1007, offset: 0x03ef = 1007
FAT16: ret: 0x000003f0, entry: 0x000003ef, offset: 0x03ef
FAT16: entry: 0x000003f0 = 1008, offset: 0x03f0 = 1008
FAT16: ret: 0x000003f1, entry: 0x000003f0, offset: 0x03f0
FAT16: entry: 0x000003f1 = 1009, offset: 0x03f1 = 1009
FAT16: ret: 0x000003f2, entry: 0x000003f1, offset: 0x03f1
FAT16: entry: 0x000003f2 = 1010, offset: 0x03f2 = 1010
FAT16: ret: 0x000003f3, entry: 0x000003f2, offset: 0x03f2
FAT16: entry: 0x000003f3 = 1011, offset: 0x03f3 = 1011
FAT16: ret: 0x000003f4, entry: 0x000003f3, offset: 0x03f3
FAT16: entry: 0x000003f4 = 1012, offset: 0x03f4 = 1012
FAT16: ret: 0x000003f5, entry: 0x000003f4, offset: 0x03f4
FAT16: entry: 0x000003f5 = 1013, offset: 0x03f5 = 1013
FAT16: ret: 0x000003f6, entry: 0x000003f5, offset: 0x03f5
FAT16: entry: 0x000003f6 = 1014, offset: 0x03f6 = 1014
FAT16: ret: 0x000005f7, entry: 0x000003f6, offset: 0x03f6
gc - clustnum: 751, startsect: 3429
FAT16: entry: 0x000003f6 = 1014, offset: 0x03f6 = 1014
FAT16: ret: 0x000005f7, entry: 0x000003f6, offset: 0x03f6
FAT16: entry: 0x000005f7 = 1527, offset: 0x05f7 = 1527
FAT16: ret: 0x000005f8, entry: 0x000005f7, offset: 0x05f7
FAT16: entry: 0x000005f8 = 1528, offset: 0x05f8 = 1528
FAT16: ret: 0x000005f9, entry: 0x000005f8, offset: 0x05f8
FAT16: entry: 0x000005f9 = 1529, offset: 0x05f9 = 1529
FAT16: ret: 0x000005fa, entry: 0x000005f9, offset: 0x05f9
FAT16: entry: 0x000005fa = 1530, offset: 0x05fa = 1530
FAT16: ret: 0x000005fb, entry: 0x000005fa, offset: 0x05fa
FAT16: entry: 0x000005fb = 1531, offset: 0x05fb = 1531
FAT16: ret: 0x000005fc, entry: 0x000005fb, offset: 0x05fb
FAT16: entry: 0x000005fc = 1532, offset: 0x05fc = 1532
FAT16: ret: 0x000005fd, entry: 0x000005fc, offset: 0x05fc
FAT16: entry: 0x000005fd = 1533, offset: 0x05fd = 1533
FAT16: ret: 0x000005fe, entry: 0x000005fd, offset: 0x05fd
FAT16: entry: 0x000005fe = 1534, offset: 0x05fe = 1534
FAT16: ret: 0x000005ff, entry: 0x000005fe, offset: 0x05fe
FAT16: entry: 0x000005ff = 1535, offset: 0x05ff = 1535
FAT16: ret: 0x00000600, entry: 0x000005ff, offset: 0x05ff
FAT16: entry: 0x00000600 = 1536, offset: 0x0000 = 0
debug: evicting 0, dirty: 0
FAT16: ret: 0x00000601, entry: 0x00000600, offset: 0x0000
FAT16: entry: 0x00000601 = 1537, offset: 0x0001 = 1
FAT16: ret: 0x00000602, entry: 0x00000601, offset: 0x0001
FAT16: entry: 0x00000602 = 1538, offset: 0x0002 = 2
FAT16: ret: 0x00000603, entry: 0x00000602, offset: 0x0002
FAT16: entry: 0x00000603 = 1539, offset: 0x0003 = 3
FAT16: ret: 0x00000604, entry: 0x00000603, offset: 0x0003
FAT16: entry: 0x00000604 = 1540, offset: 0x0004 = 4
FAT16: ret: 0x00000605, entry: 0x00000604, offset: 0x0004
FAT16: entry: 0x00000605 = 1541, offset: 0x0005 = 5
FAT16: ret: 0x00000606, entry: 0x00000605, offset: 0x0005
FAT16: entry: 0x00000606 = 1542, offset: 0x0006 = 6
FAT16: ret: 0x00000607, entry: 0x00000606, offset: 0x0006
FAT16: entry: 0x00000607 = 1543, offset: 0x0007 = 7
FAT16: ret: 0x00000608, entry: 0x00000607, offset: 0x0007
FAT16: entry: 0x00000608 = 1544, offset: 0x0008 = 8
FAT16: ret: 0x00000609, entry: 0x00000608, offset: 0x0008
FAT16: entry: 0x00000609 = 1545, offset: 0x0009 = 9
FAT16: ret: 0x0000060a, entry: 0x00000609, offset: 0x0009
FAT16: entry: 0x0000060a = 1546, offset: 0x000a = 10
FAT16: ret: 0x0000060b, entry: 0x0000060a, offset: 0x000a
FAT16: entry: 0x0000060b = 1547, offset: 0x000b = 11
FAT16: ret: 0x0000060c, entry: 0x0000060b, offset: 0x000b
FAT16: entry: 0x0000060c = 1548, offset: 0x000c = 12
FAT16: ret: 0x0000060d, entry: 0x0000060c, offset: 0x000c
FAT16: entry: 0x0000060d = 1549, offset: 0x000d = 13
FAT16: ret: 0x0000060e, entry: 0x0000060d, offset: 0x000d
FAT16: entry: 0x0000060e = 1550, offset: 0x000e = 14
FAT16: ret: 0x0000060f, entry: 0x0000060e, offset: 0x000e
FAT16: entry: 0x0000060f = 1551, offset: 0x000f = 15
FAT16: ret: 0x00000610, entry: 0x0000060f, offset: 0x000f
FAT16: entry: 0x00000610 = 1552, offset: 0x0010 = 16
FAT16: ret: 0x00000611, entry: 0x00000610, offset: 0x0010
FAT16: entry: 0x00000611 = 1553, offset: 0x0011 = 17
FAT16: ret: 0x00000612, entry: 0x00000611, offset: 0x0011
FAT16: entry: 0x00000612 = 1554, offset: 0x0012 = 18
FAT16: ret: 0x00000613, entry: 0x00000612, offset: 0x0012
FAT16: entry: 0x00000613 = 1555, offset: 0x0013 = 19
FAT16: ret: 0x00000614, entry: 0x00000613, offset: 0x0013
FAT16: entry: 0x00000614 = 1556, offset: 0x0014 = 20
FAT16: ret: 0x00000615, entry: 0x00000614, offset: 0x0014
FAT16: entry: 0x00000615 = 1557, offset: 0x0015 = 21
FAT16: ret: 0x00000616, entry: 0x00000615, offset: 0x0015
FAT16: entry: 0x00000616 = 1558, offset: 0x0016 = 22
FAT16: ret: 0x00000617, entry: 0x00000616, offset: 0x0016
FAT16: entry: 0x00000617 = 1559, offset: 0x0017 = 23
FAT16: ret: 0x00000618, entry: 0x00000617, offset: 0x0017
FAT16: entry: 0x00000618 = 1560, offset: 0x0018 = 24
FAT16: ret: 0x00000619, entry: 0x00000618, offset: 0x0018
FAT16: entry: 0x00000619 = 1561, offset: 0x0019 = 25
FAT16: ret: 0x0000061a, entry: 0x00000619, offset: 0x0019
FAT16: entry: 0x0000061a = 1562, offset: 0x001a = 26
FAT16: ret: 0x0000061b, entry: 0x0000061a, offset: 0x001a
FAT16: entry: 0x0000061b = 1563, offset: 0x001b = 27
FAT16: ret: 0x0000061c, entry: 0x0000061b, offset: 0x001b
FAT16: entry: 0x0000061c = 1564, offset: 0x001c = 28
FAT16: ret: 0x0000061d, entry: 0x0000061c, offset: 0x001c
FAT16: entry: 0x0000061d = 1565, offset: 0x001d = 29
FAT16: ret: 0x0000061e, entry: 0x0000061d, offset: 0x001d
FAT16: entry: 0x0000061e = 1566, offset: 0x001e = 30
FAT16: ret: 0x0000061f, entry: 0x0000061e, offset: 0x001e
FAT16: entry: 0x0000061f = 1567, offset: 0x001f = 31
FAT16: ret: 0x00000620, entry: 0x0000061f, offset: 0x001f
FAT16: entry: 0x00000620 = 1568, offset: 0x0020 = 32
FAT16: ret: 0x00000621, entry: 0x00000620, offset: 0x0020
FAT16: entry: 0x00000621 = 1569, offset: 0x0021 = 33
FAT16: ret: 0x00000622, entry: 0x00000621, offset: 0x0021
FAT16: entry: 0x00000622 = 1570, offset: 0x0022 = 34
FAT16: ret: 0x00000623, entry: 0x00000622, offset: 0x0022
FAT16: entry: 0x00000623 = 1571, offset: 0x0023 = 35
FAT16: ret: 0x00000624, entry: 0x00000623, offset: 0x0023
FAT16: entry: 0x00000624 = 1572, offset: 0x0024 = 36
FAT16: ret: 0x00000625, entry: 0x00000624, offset: 0x0024
FAT16: entry: 0x00000625 = 1573, offset: 0x0025 = 37
FAT16: ret: 0x00000626, entry: 0x00000625, offset: 0x0025
FAT16: entry: 0x00000626 = 1574, offset: 0x0026 = 38
FAT16: ret: 0x00000627, entry: 0x00000626, offset: 0x0026
FAT16: entry: 0x00000627 = 1575, offset: 0x0027 = 39
FAT16: ret: 0x00000628, entry: 0x00000627, offset: 0x0027
FAT16: entry: 0x00000628 = 1576, offset: 0x0028 = 40
FAT16: ret: 0x00000629, entry: 0x00000628, offset: 0x0028
FAT16: entry: 0x00000629 = 1577, offset: 0x0029 = 41
FAT16: ret: 0x0000062a, entry: 0x00000629, offset: 0x0029
FAT16: entry: 0x0000062a = 1578, offset: 0x002a = 42
FAT16: ret: 0x0000062b, entry: 0x0000062a, offset: 0x002a
FAT16: entry: 0x0000062b = 1579, offset: 0x002b = 43
FAT16: ret: 0x0000062c, entry: 0x0000062b, offset: 0x002b
gc - clustnum: 1527, startsect: 6533
1048576 bytes read in 5128 ms (199.2 KiB/s)
byte at 0x83061000 (0xca) != byte at 0x82061000 (0x8f)
Total of 397312 byte(s) were the same
=>

On 11/09/2018 08:59, Akashi, Takahiro wrote:
> From: AKASHI Takahiro <takahiro.akashi@linaro.org>
>
> In this patch, all the necessary code for allowing for a file offset
> at write is implemented. What plays a major roll here is get_set_cluster(),
> which, in contrast to its counterpart, set_cluster(), only operates on
> already-allocated clusters, overwriting with data.
>
> So, with a file offset specified, set_contents() seeks and writes data
> with set_get_cluster() until the end of a file, and, once it reaches
> there, continues writing with set_cluster() for the rest.
>
> Please note that a file will be trimmed as a result of write operation if
> write ends before reaching file's end. This is an intended behavior
> in order to maintain compatibility with the current interface.
>
> Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
> ---
>   fs/fat/fat_write.c | 288 ++++++++++++++++++++++++++++++++++++++++++---
>   1 file changed, 273 insertions(+), 15 deletions(-)
>
> diff --git a/fs/fat/fat_write.c b/fs/fat/fat_write.c
> index c22d8c7a46a1..651c7866debc 100644
> --- a/fs/fat/fat_write.c
> +++ b/fs/fat/fat_write.c
> @@ -450,6 +450,121 @@ set_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer,
>   	return 0;
>   }
>   

[U-Boot] [PATCH v3 10/26] fs: fat: support write with non-zero offset

[Clément Péron]

Hi,

Trying to rebuild my SoCFPGA Cyclone V board and got this error :

fs/built-in.o: In function `set_contents':
/home/cperon/u-boot/fs/fat/fat_write.c:831: undefined reference to
`__aeabi_ldivmod'
make: *** [Makefile:1381: u-boot] Error 1

seems to be introduced with this operation :
assert(!(cur_pos % bytesperclust));

toolchain used :
gcc version 7.3.1 20180622 (release) [ARM/embedded-7-branch revision
261907] (GNU Tools for Arm Embedded Processors 7-2018-q2-update)

Regards,
Clement
On Mon, 15 Oct 2018 at 14:12, Jean-Jacques Hiblot <jjhiblot@ti.com> wrote:
>
> This sometimes breaks fat writes.
>
> The tests is simple: load a file from tftp, write it on MMC, read it
> back and compare
>
> I can provide an image of the partition if needed.
>
> JJ
>
>
> => setenv autoload no; dhcp; setenv serverip 192.168.1.42; tftp
> $loadaddr test; echo WRITING !; fatwrite mmc 0 $loadaddr u-boot.img
> $filesize; mmc dev 1; mmc dev 0 ; echo READING! ; fatload mmc 0
> 0x83000000 u-boot.img; cmp.b 0x83000000 $loadae
> link up on port 0, speed 1000, full duplex
> BOOTP broadcast 1
> DHCP client bound to address 192.168.1.27 (2004 ms)
> link up on port 0, speed 1000, full duplex
> Using ethernet at 48484000 device
> TFTP from server 192.168.1.42; our IP address is 192.168.1.27
> Filename 'test'.
> Load address: 0x82000000
> Loading: #################################################################
>           #######
>           5.2 MiB/s
> done
> Bytes transferred = 1048576 (100000 hex)
> WRITING !
> writing u-boot.img
> FAT16, fat_sect: 1, fatlength: 200
> Rootdir begins at cluster: -6, sector: 401, offset: 32200
> Data begins at: 425
> Sector size: 512, cluster size: 4
> FAT read(sect=401), clust_size=4, DIRENTSPERBLOCK=16
> 1048576 bytes
> FAT16: entry: 0x0000020d = 525, offset: 0x020d = 525
> debug: evicting -1, dirty: 0
> FAT16: ret: 0x0000020e, entry: 0x0000020d, offset: 0x020d
> FAT16: entry: 0x0000020e = 526, offset: 0x020e = 526
> FAT16: ret: 0x0000020f, entry: 0x0000020e, offset: 0x020e
> FAT16: entry: 0x0000020f = 527, offset: 0x020f = 527
> FAT16: ret: 0x00000210, entry: 0x0000020f, offset: 0x020f
> FAT16: entry: 0x00000210 = 528, offset: 0x0210 = 528
> FAT16: ret: 0x00000211, entry: 0x00000210, offset: 0x0210
> FAT16: entry: 0x00000211 = 529, offset: 0x0211 = 529
> FAT16: ret: 0x00000212, entry: 0x00000211, offset: 0x0211
> FAT16: entry: 0x00000212 = 530, offset: 0x0212 = 530
> FAT16: ret: 0x00000213, entry: 0x00000212, offset: 0x0212
> FAT16: entry: 0x00000213 = 531, offset: 0x0213 = 531
> FAT16: ret: 0x00000214, entry: 0x00000213, offset: 0x0213
> FAT16: entry: 0x00000214 = 532, offset: 0x0214 = 532
> FAT16: ret: 0x00000215, entry: 0x00000214, offset: 0x0214
> FAT16: entry: 0x00000215 = 533, offset: 0x0215 = 533
> FAT16: ret: 0x00000216, entry: 0x00000215, offset: 0x0215
> FAT16: entry: 0x00000216 = 534, offset: 0x0216 = 534
> FAT16: ret: 0x00000217, entry: 0x00000216, offset: 0x0216
> FAT16: entry: 0x00000217 = 535, offset: 0x0217 = 535
> FAT16: ret: 0x00000218, entry: 0x00000217, offset: 0x0217
> FAT16: entry: 0x00000218 = 536, offset: 0x0218 = 536
> FAT16: ret: 0x00000219, entry: 0x00000218, offset: 0x0218
> FAT16: entry: 0x00000219 = 537, offset: 0x0219 = 537
> FAT16: ret: 0x0000021a, entry: 0x00000219, offset: 0x0219
> FAT16: entry: 0x0000021a = 538, offset: 0x021a = 538
> FAT16: ret: 0x0000021b, entry: 0x0000021a, offset: 0x021a
> FAT16: entry: 0x0000021b = 539, offset: 0x021b = 539
> FAT16: ret: 0x0000021c, entry: 0x0000021b, offset: 0x021b
> FAT16: entry: 0x0000021c = 540, offset: 0x021c = 540
> FAT16: ret: 0x0000021d, entry: 0x0000021c, offset: 0x021c
> FAT16: entry: 0x0000021d = 541, offset: 0x021d = 541
> FAT16: ret: 0x0000021e, entry: 0x0000021d, offset: 0x021d
> FAT16: entry: 0x0000021e = 542, offset: 0x021e = 542
> FAT16: ret: 0x0000021f, entry: 0x0000021e, offset: 0x021e
> FAT16: entry: 0x0000021f = 543, offset: 0x021f = 543
> FAT16: ret: 0x00000220, entry: 0x0000021f, offset: 0x021f
> FAT16: entry: 0x00000220 = 544, offset: 0x0220 = 544
> FAT16: ret: 0x00000221, entry: 0x00000220, offset: 0x0220
> FAT16: entry: 0x00000221 = 545, offset: 0x0221 = 545
> FAT16: ret: 0x00000222, entry: 0x00000221, offset: 0x0221
> FAT16: entry: 0x00000222 = 546, offset: 0x0222 = 546
> FAT16: ret: 0x00000223, entry: 0x00000222, offset: 0x0222
> FAT16: entry: 0x00000223 = 547, offset: 0x0223 = 547
> FAT16: ret: 0x00000224, entry: 0x00000223, offset: 0x0223
> FAT16: entry: 0x00000224 = 548, offset: 0x0224 = 548
> FAT16: ret: 0x00000225, entry: 0x00000224, offset: 0x0224
> FAT16: entry: 0x00000225 = 549, offset: 0x0225 = 549
> FAT16: ret: 0x00000226, entry: 0x00000225, offset: 0x0225
> FAT16: entry: 0x00000226 = 550, offset: 0x0226 = 550
> FAT16: ret: 0x00000227, entry: 0x00000226, offset: 0x0226
> FAT16: entry: 0x00000227 = 551, offset: 0x0227 = 551
> FAT16: ret: 0x00000228, entry: 0x00000227, offset: 0x0227
> FAT16: entry: 0x00000228 = 552, offset: 0x0228 = 552
> FAT16: ret: 0x00000229, entry: 0x00000228, offset: 0x0228
> FAT16: entry: 0x00000229 = 553, offset: 0x0229 = 553
> FAT16: ret: 0x0000022a, entry: 0x00000229, offset: 0x0229
> FAT16: entry: 0x0000022a = 554, offset: 0x022a = 554
> FAT16: ret: 0x0000022b, entry: 0x0000022a, offset: 0x022a
> FAT16: entry: 0x0000022b = 555, offset: 0x022b = 555
> FAT16: ret: 0x0000022c, entry: 0x0000022b, offset: 0x022b
> FAT16: entry: 0x0000022c = 556, offset: 0x022c = 556
> FAT16: ret: 0x0000022d, entry: 0x0000022c, offset: 0x022c
> FAT16: entry: 0x0000022d = 557, offset: 0x022d = 557
> FAT16: ret: 0x0000022e, entry: 0x0000022d, offset: 0x022d
> FAT16: entry: 0x0000022e = 558, offset: 0x022e = 558
> FAT16: ret: 0x0000022f, entry: 0x0000022e, offset: 0x022e
> FAT16: entry: 0x0000022f = 559, offset: 0x022f = 559
> FAT16: ret: 0x00000230, entry: 0x0000022f, offset: 0x022f
> FAT16: entry: 0x00000230 = 560, offset: 0x0230 = 560
> FAT16: ret: 0x00000231, entry: 0x00000230, offset: 0x0230
> FAT16: entry: 0x00000231 = 561, offset: 0x0231 = 561
> FAT16: ret: 0x00000232, entry: 0x00000231, offset: 0x0231
> FAT16: entry: 0x00000232 = 562, offset: 0x0232 = 562
> FAT16: ret: 0x00000233, entry: 0x00000232, offset: 0x0232
> FAT16: entry: 0x00000233 = 563, offset: 0x0233 = 563
> FAT16: ret: 0x00000234, entry: 0x00000233, offset: 0x0233
> FAT16: entry: 0x00000234 = 564, offset: 0x0234 = 564
> FAT16: ret: 0x00000235, entry: 0x00000234, offset: 0x0234
> FAT16: entry: 0x00000235 = 565, offset: 0x0235 = 565
> FAT16: ret: 0x00000236, entry: 0x00000235, offset: 0x0235
> FAT16: entry: 0x00000236 = 566, offset: 0x0236 = 566
> FAT16: ret: 0x00000237, entry: 0x00000236, offset: 0x0236
> FAT16: entry: 0x00000237 = 567, offset: 0x0237 = 567
> FAT16: ret: 0x00000238, entry: 0x00000237, offset: 0x0237
> FAT16: entry: 0x00000238 = 568, offset: 0x0238 = 568
> FAT16: ret: 0x00000239, entry: 0x00000238, offset: 0x0238
> FAT16: entry: 0x00000239 = 569, offset: 0x0239 = 569
> FAT16: ret: 0x0000023a, entry: 0x00000239, offset: 0x0239
> FAT16: entry: 0x0000023a = 570, offset: 0x023a = 570
> FAT16: ret: 0x0000023b, entry: 0x0000023a, offset: 0x023a
> FAT16: entry: 0x0000023b = 571, offset: 0x023b = 571
> FAT16: ret: 0x0000023c, entry: 0x0000023b, offset: 0x023b
> FAT16: entry: 0x0000023c = 572, offset: 0x023c = 572
> FAT16: ret: 0x0000023d, entry: 0x0000023c, offset: 0x023c
> FAT16: entry: 0x0000023d = 573, offset: 0x023d = 573
> FAT16: ret: 0x0000023e, entry: 0x0000023d, offset: 0x023d
> FAT16: entry: 0x0000023e = 574, offset: 0x023e = 574
> FAT16: ret: 0x0000023f, entry: 0x0000023e, offset: 0x023e
> FAT16: entry: 0x0000023f = 575, offset: 0x023f = 575
> FAT16: ret: 0x00000240, entry: 0x0000023f, offset: 0x023f
> FAT16: entry: 0x00000240 = 576, offset: 0x0240 = 576
> FAT16: ret: 0x00000241, entry: 0x00000240, offset: 0x0240
> FAT16: entry: 0x00000241 = 577, offset: 0x0241 = 577
> FAT16: ret: 0x00000242, entry: 0x00000241, offset: 0x0241
> FAT16: entry: 0x00000242 = 578, offset: 0x0242 = 578
> FAT16: ret: 0x00000243, entry: 0x00000242, offset: 0x0242
> FAT16: entry: 0x00000243 = 579, offset: 0x0243 = 579
> FAT16: ret: 0x00000244, entry: 0x00000243, offset: 0x0243
> FAT16: entry: 0x00000244 = 580, offset: 0x0244 = 580
> FAT16: ret: 0x00000245, entry: 0x00000244, offset: 0x0244
> FAT16: entry: 0x00000245 = 581, offset: 0x0245 = 581
> FAT16: ret: 0x00000246, entry: 0x00000245, offset: 0x0245
> FAT16: entry: 0x00000246 = 582, offset: 0x0246 = 582
> FAT16: ret: 0x00000247, entry: 0x00000246, offset: 0x0246
> FAT16: entry: 0x00000247 = 583, offset: 0x0247 = 583
> FAT16: ret: 0x00000248, entry: 0x00000247, offset: 0x0247
> FAT16: entry: 0x00000248 = 584, offset: 0x0248 = 584
> FAT16: ret: 0x00000249, entry: 0x00000248, offset: 0x0248
> FAT16: entry: 0x00000249 = 585, offset: 0x0249 = 585
> FAT16: ret: 0x0000024a, entry: 0x00000249, offset: 0x0249
> FAT16: entry: 0x0000024a = 586, offset: 0x024a = 586
> FAT16: ret: 0x0000024b, entry: 0x0000024a, offset: 0x024a
> FAT16: entry: 0x0000024b = 587, offset: 0x024b = 587
> FAT16: ret: 0x0000024c, entry: 0x0000024b, offset: 0x024b
> FAT16: entry: 0x0000024c = 588, offset: 0x024c = 588
> FAT16: ret: 0x0000024d, entry: 0x0000024c, offset: 0x024c
> FAT16: entry: 0x0000024d = 589, offset: 0x024d = 589
> FAT16: ret: 0x0000024e, entry: 0x0000024d, offset: 0x024d
> FAT16: entry: 0x0000024e = 590, offset: 0x024e = 590
> FAT16: ret: 0x0000024f, entry: 0x0000024e, offset: 0x024e
> FAT16: entry: 0x0000024f = 591, offset: 0x024f = 591
> FAT16: ret: 0x00000250, entry: 0x0000024f, offset: 0x024f
> FAT16: entry: 0x00000250 = 592, offset: 0x0250 = 592
> FAT16: ret: 0x00000251, entry: 0x00000250, offset: 0x0250
> FAT16: entry: 0x00000251 = 593, offset: 0x0251 = 593
> FAT16: ret: 0x00000252, entry: 0x00000251, offset: 0x0251
> FAT16: entry: 0x00000252 = 594, offset: 0x0252 = 594
> FAT16: ret: 0x00000253, entry: 0x00000252, offset: 0x0252
> FAT16: entry: 0x00000253 = 595, offset: 0x0253 = 595
> FAT16: ret: 0x00000254, entry: 0x00000253, offset: 0x0253
> FAT16: entry: 0x00000254 = 596, offset: 0x0254 = 596
> FAT16: ret: 0x00000255, entry: 0x00000254, offset: 0x0254
> FAT16: entry: 0x00000255 = 597, offset: 0x0255 = 597
> FAT16: ret: 0x00000256, entry: 0x00000255, offset: 0x0255
> FAT16: entry: 0x00000256 = 598, offset: 0x0256 = 598
> FAT16: ret: 0x00000257, entry: 0x00000256, offset: 0x0256
> FAT16: entry: 0x00000257 = 599, offset: 0x0257 = 599
> FAT16: ret: 0x00000258, entry: 0x00000257, offset: 0x0257
> FAT16: entry: 0x00000258 = 600, offset: 0x0258 = 600
> FAT16: ret: 0x00000259, entry: 0x00000258, offset: 0x0258
> FAT16: entry: 0x00000259 = 601, offset: 0x0259 = 601
> FAT16: ret: 0x0000025a, entry: 0x00000259, offset: 0x0259
> FAT16: entry: 0x0000025a = 602, offset: 0x025a = 602
> FAT16: ret: 0x0000025b, entry: 0x0000025a, offset: 0x025a
> FAT16: entry: 0x0000025b = 603, offset: 0x025b = 603
> FAT16: ret: 0x0000025c, entry: 0x0000025b, offset: 0x025b
> FAT16: entry: 0x0000025c = 604, offset: 0x025c = 604
> FAT16: ret: 0x0000025d, entry: 0x0000025c, offset: 0x025c
> FAT16: entry: 0x0000025d = 605, offset: 0x025d = 605
> FAT16: ret: 0x0000025e, entry: 0x0000025d, offset: 0x025d
> FAT16: entry: 0x0000025e = 606, offset: 0x025e = 606
> FAT16: ret: 0x0000025f, entry: 0x0000025e, offset: 0x025e
> FAT16: entry: 0x0000025f = 607, offset: 0x025f = 607
> FAT16: ret: 0x00000260, entry: 0x0000025f, offset: 0x025f
> FAT16: entry: 0x00000260 = 608, offset: 0x0260 = 608
> FAT16: ret: 0x00000261, entry: 0x00000260, offset: 0x0260
> FAT16: entry: 0x00000261 = 609, offset: 0x0261 = 609
> FAT16: ret: 0x00000262, entry: 0x00000261, offset: 0x0261
> FAT16: entry: 0x00000262 = 610, offset: 0x0262 = 610
> FAT16: ret: 0x00000263, entry: 0x00000262, offset: 0x0262
> FAT16: entry: 0x00000263 = 611, offset: 0x0263 = 611
> FAT16: ret: 0x00000264, entry: 0x00000263, offset: 0x0263
> FAT16: entry: 0x00000264 = 612, offset: 0x0264 = 612
> FAT16: ret: 0x00000265, entry: 0x00000264, offset: 0x0264
> FAT16: entry: 0x00000265 = 613, offset: 0x0265 = 613
> FAT16: ret: 0x00000266, entry: 0x00000265, offset: 0x0265
> FAT16: entry: 0x00000266 = 614, offset: 0x0266 = 614
> FAT16: ret: 0x00000267, entry: 0x00000266, offset: 0x0266
> FAT16: entry: 0x00000267 = 615, offset: 0x0267 = 615
> FAT16: ret: 0x00000268, entry: 0x00000267, offset: 0x0267
> FAT16: entry: 0x00000268 = 616, offset: 0x0268 = 616
> FAT16: ret: 0x00000269, entry: 0x00000268, offset: 0x0268
> FAT16: entry: 0x00000269 = 617, offset: 0x0269 = 617
> FAT16: ret: 0x0000026a, entry: 0x00000269, offset: 0x0269
> FAT16: entry: 0x0000026a = 618, offset: 0x026a = 618
> FAT16: ret: 0x0000026b, entry: 0x0000026a, offset: 0x026a
> FAT16: entry: 0x0000026b = 619, offset: 0x026b = 619
> FAT16: ret: 0x0000026c, entry: 0x0000026b, offset: 0x026b
> FAT16: entry: 0x0000026c = 620, offset: 0x026c = 620
> FAT16: ret: 0x0000026d, entry: 0x0000026c, offset: 0x026c
> FAT16: entry: 0x0000026d = 621, offset: 0x026d = 621
> FAT16: ret: 0x0000026e, entry: 0x0000026d, offset: 0x026d
> FAT16: entry: 0x0000026e = 622, offset: 0x026e = 622
> FAT16: ret: 0x0000026f, entry: 0x0000026e, offset: 0x026e
> FAT16: entry: 0x0000026f = 623, offset: 0x026f = 623
> FAT16: ret: 0x00000270, entry: 0x0000026f, offset: 0x026f
> FAT16: entry: 0x00000270 = 624, offset: 0x0270 = 624
> FAT16: ret: 0x00000271, entry: 0x00000270, offset: 0x0270
> FAT16: entry: 0x00000271 = 625, offset: 0x0271 = 625
> FAT16: ret: 0x00000272, entry: 0x00000271, offset: 0x0271
> FAT16: entry: 0x00000272 = 626, offset: 0x0272 = 626
> FAT16: ret: 0x00000273, entry: 0x00000272, offset: 0x0272
> FAT16: entry: 0x00000273 = 627, offset: 0x0273 = 627
> FAT16: ret: 0x00000274, entry: 0x00000273, offset: 0x0273
> FAT16: entry: 0x00000274 = 628, offset: 0x0274 = 628
> FAT16: ret: 0x00000275, entry: 0x00000274, offset: 0x0274
> FAT16: entry: 0x00000275 = 629, offset: 0x0275 = 629
> FAT16: ret: 0x00000276, entry: 0x00000275, offset: 0x0275
> FAT16: entry: 0x00000276 = 630, offset: 0x0276 = 630
> FAT16: ret: 0x00000277, entry: 0x00000276, offset: 0x0276
> FAT16: entry: 0x00000277 = 631, offset: 0x0277 = 631
> FAT16: ret: 0x00000278, entry: 0x00000277, offset: 0x0277
> FAT16: entry: 0x00000278 = 632, offset: 0x0278 = 632
> FAT16: ret: 0x00000279, entry: 0x00000278, offset: 0x0278
> FAT16: entry: 0x00000279 = 633, offset: 0x0279 = 633
> FAT16: ret: 0x0000027a, entry: 0x00000279, offset: 0x0279
> FAT16: entry: 0x0000027a = 634, offset: 0x027a = 634
> FAT16: ret: 0x0000027b, entry: 0x0000027a, offset: 0x027a
> FAT16: entry: 0x0000027b = 635, offset: 0x027b = 635
> FAT16: ret: 0x0000027c, entry: 0x0000027b, offset: 0x027b
> FAT16: entry: 0x0000027c = 636, offset: 0x027c = 636
> FAT16: ret: 0x0000027d, entry: 0x0000027c, offset: 0x027c
> FAT16: entry: 0x0000027d = 637, offset: 0x027d = 637
> FAT16: ret: 0x0000027e, entry: 0x0000027d, offset: 0x027d
> FAT16: entry: 0x0000027e = 638, offset: 0x027e = 638
> FAT16: ret: 0x0000027f, entry: 0x0000027e, offset: 0x027e
> FAT16: entry: 0x0000027f = 639, offset: 0x027f = 639
> FAT16: ret: 0x00000280, entry: 0x0000027f, offset: 0x027f
> FAT16: entry: 0x00000280 = 640, offset: 0x0280 = 640
> FAT16: ret: 0x00000281, entry: 0x00000280, offset: 0x0280
> FAT16: entry: 0x00000281 = 641, offset: 0x0281 = 641
> FAT16: ret: 0x00000282, entry: 0x00000281, offset: 0x0281
> FAT16: entry: 0x00000282 = 642, offset: 0x0282 = 642
> FAT16: ret: 0x00000283, entry: 0x00000282, offset: 0x0282
> FAT16: entry: 0x00000283 = 643, offset: 0x0283 = 643
> FAT16: ret: 0x00000284, entry: 0x00000283, offset: 0x0283
> FAT16: entry: 0x00000284 = 644, offset: 0x0284 = 644
> FAT16: ret: 0x00000285, entry: 0x00000284, offset: 0x0284
> FAT16: entry: 0x00000285 = 645, offset: 0x0285 = 645
> FAT16: ret: 0x00000286, entry: 0x00000285, offset: 0x0285
> FAT16: entry: 0x00000286 = 646, offset: 0x0286 = 646
> FAT16: ret: 0x00000287, entry: 0x00000286, offset: 0x0286
> FAT16: entry: 0x00000287 = 647, offset: 0x0287 = 647
> FAT16: ret: 0x00000288, entry: 0x00000287, offset: 0x0287
> FAT16: entry: 0x00000288 = 648, offset: 0x0288 = 648
> FAT16: ret: 0x00000289, entry: 0x00000288, offset: 0x0288
> FAT16: entry: 0x00000289 = 649, offset: 0x0289 = 649
> FAT16: ret: 0x0000028a, entry: 0x00000289, offset: 0x0289
> FAT16: entry: 0x0000028a = 650, offset: 0x028a = 650
> FAT16: ret: 0x0000028b, entry: 0x0000028a, offset: 0x028a
> FAT16: entry: 0x0000028b = 651, offset: 0x028b = 651
> FAT16: ret: 0x0000028c, entry: 0x0000028b, offset: 0x028b
> FAT16: entry: 0x0000028c = 652, offset: 0x028c = 652
> FAT16: ret: 0x0000028d, entry: 0x0000028c, offset: 0x028c
> FAT16: entry: 0x0000028d = 653, offset: 0x028d = 653
> FAT16: ret: 0x0000028e, entry: 0x0000028d, offset: 0x028d
> FAT16: entry: 0x0000028e = 654, offset: 0x028e = 654
> FAT16: ret: 0x0000028f, entry: 0x0000028e, offset: 0x028e
> FAT16: entry: 0x0000028f = 655, offset: 0x028f = 655
> FAT16: ret: 0x00000290, entry: 0x0000028f, offset: 0x028f
> FAT16: entry: 0x00000290 = 656, offset: 0x0290 = 656
> FAT16: ret: 0x00000291, entry: 0x00000290, offset: 0x0290
> FAT16: entry: 0x00000291 = 657, offset: 0x0291 = 657
> FAT16: ret: 0x00000292, entry: 0x00000291, offset: 0x0291
> FAT16: entry: 0x00000292 = 658, offset: 0x0292 = 658
> FAT16: ret: 0x00000293, entry: 0x00000292, offset: 0x0292
> FAT16: entry: 0x00000293 = 659, offset: 0x0293 = 659
> FAT16: ret: 0x00000294, entry: 0x00000293, offset: 0x0293
> FAT16: entry: 0x00000294 = 660, offset: 0x0294 = 660
> FAT16: ret: 0x00000295, entry: 0x00000294, offset: 0x0294
> FAT16: entry: 0x00000295 = 661, offset: 0x0295 = 661
> FAT16: ret: 0x00000296, entry: 0x00000295, offset: 0x0295
> FAT16: entry: 0x00000296 = 662, offset: 0x0296 = 662
> FAT16: ret: 0x00000297, entry: 0x00000296, offset: 0x0296
> FAT16: entry: 0x00000297 = 663, offset: 0x0297 = 663
> FAT16: ret: 0x00000298, entry: 0x00000297, offset: 0x0297
> FAT16: entry: 0x00000298 = 664, offset: 0x0298 = 664
> FAT16: ret: 0x00000299, entry: 0x00000298, offset: 0x0298
> FAT16: entry: 0x00000299 = 665, offset: 0x0299 = 665
> FAT16: ret: 0x0000029a, entry: 0x00000299, offset: 0x0299
> FAT16: entry: 0x0000029a = 666, offset: 0x029a = 666
> FAT16: ret: 0x0000029b, entry: 0x0000029a, offset: 0x029a
> FAT16: entry: 0x0000029b = 667, offset: 0x029b = 667
> FAT16: ret: 0x0000029c, entry: 0x0000029b, offset: 0x029b
> FAT16: entry: 0x0000029c = 668, offset: 0x029c = 668
> FAT16: ret: 0x0000029d, entry: 0x0000029c, offset: 0x029c
> FAT16: entry: 0x0000029d = 669, offset: 0x029d = 669
> FAT16: ret: 0x0000029e, entry: 0x0000029d, offset: 0x029d
> FAT16: entry: 0x0000029e = 670, offset: 0x029e = 670
> FAT16: ret: 0x0000029f, entry: 0x0000029e, offset: 0x029e
> FAT16: entry: 0x0000029f = 671, offset: 0x029f = 671
> FAT16: ret: 0x000002a0, entry: 0x0000029f, offset: 0x029f
> FAT16: entry: 0x000002a0 = 672, offset: 0x02a0 = 672
> FAT16: ret: 0x000002a1, entry: 0x000002a0, offset: 0x02a0
> FAT16: entry: 0x000002a1 = 673, offset: 0x02a1 = 673
> FAT16: ret: 0x000002a2, entry: 0x000002a1, offset: 0x02a1
> FAT16: entry: 0x000002a2 = 674, offset: 0x02a2 = 674
> FAT16: ret: 0x000002a3, entry: 0x000002a2, offset: 0x02a2
> FAT16: entry: 0x000002a3 = 675, offset: 0x02a3 = 675
> FAT16: ret: 0x000002a4, entry: 0x000002a3, offset: 0x02a3
> FAT16: entry: 0x000002a4 = 676, offset: 0x02a4 = 676
> FAT16: ret: 0x000002a5, entry: 0x000002a4, offset: 0x02a4
> FAT16: entry: 0x000002a5 = 677, offset: 0x02a5 = 677
> FAT16: ret: 0x000002a6, entry: 0x000002a5, offset: 0x02a5
> FAT16: entry: 0x000002a6 = 678, offset: 0x02a6 = 678
> FAT16: ret: 0x000002a7, entry: 0x000002a6, offset: 0x02a6
> FAT16: entry: 0x000002a7 = 679, offset: 0x02a7 = 679
> FAT16: ret: 0x000002a8, entry: 0x000002a7, offset: 0x02a7
> FAT16: entry: 0x000002a8 = 680, offset: 0x02a8 = 680
> FAT16: ret: 0x000002a9, entry: 0x000002a8, offset: 0x02a8
> FAT16: entry: 0x000002a9 = 681, offset: 0x02a9 = 681
> FAT16: ret: 0x000002aa, entry: 0x000002a9, offset: 0x02a9
> FAT16: entry: 0x000002aa = 682, offset: 0x02aa = 682
> FAT16: ret: 0x000002ab, entry: 0x000002aa, offset: 0x02aa
> FAT16: entry: 0x000002ab = 683, offset: 0x02ab = 683
> FAT16: ret: 0x000002ac, entry: 0x000002ab, offset: 0x02ab
> FAT16: entry: 0x000002ac = 684, offset: 0x02ac = 684
> FAT16: ret: 0x000002ad, entry: 0x000002ac, offset: 0x02ac
> FAT16: entry: 0x000002ad = 685, offset: 0x02ad = 685
> FAT16: ret: 0x000002ae, entry: 0x000002ad, offset: 0x02ad
> FAT16: entry: 0x000002ae = 686, offset: 0x02ae = 686
> FAT16: ret: 0x000002af, entry: 0x000002ae, offset: 0x02ae
> FAT16: entry: 0x000002af = 687, offset: 0x02af = 687
> FAT16: ret: 0x000002b0, entry: 0x000002af, offset: 0x02af
> FAT16: entry: 0x000002b0 = 688, offset: 0x02b0 = 688
> FAT16: ret: 0x000002b1, entry: 0x000002b0, offset: 0x02b0
> FAT16: entry: 0x000002b1 = 689, offset: 0x02b1 = 689
> FAT16: ret: 0x000002b2, entry: 0x000002b1, offset: 0x02b1
> FAT16: entry: 0x000002b2 = 690, offset: 0x02b2 = 690
> FAT16: ret: 0x000002b3, entry: 0x000002b2, offset: 0x02b2
> FAT16: entry: 0x000002b3 = 691, offset: 0x02b3 = 691
> FAT16: ret: 0x000002b4, entry: 0x000002b3, offset: 0x02b3
> FAT16: entry: 0x000002b4 = 692, offset: 0x02b4 = 692
> FAT16: ret: 0x000002b5, entry: 0x000002b4, offset: 0x02b4
> FAT16: entry: 0x000002b5 = 693, offset: 0x02b5 = 693
> FAT16: ret: 0x000002b6, entry: 0x000002b5, offset: 0x02b5
> FAT16: entry: 0x000002b6 = 694, offset: 0x02b6 = 694
> FAT16: ret: 0x000002b7, entry: 0x000002b6, offset: 0x02b6
> FAT16: entry: 0x000002b7 = 695, offset: 0x02b7 = 695
> FAT16: ret: 0x000002b8, entry: 0x000002b7, offset: 0x02b7
> FAT16: entry: 0x000002b8 = 696, offset: 0x02b8 = 696
> FAT16: ret: 0x000002b9, entry: 0x000002b8, offset: 0x02b8
> FAT16: entry: 0x000002b9 = 697, offset: 0x02b9 = 697
> FAT16: ret: 0x000002ba, entry: 0x000002b9, offset: 0x02b9
> FAT16: entry: 0x000002ba = 698, offset: 0x02ba = 698
> FAT16: ret: 0x000002bb, entry: 0x000002ba, offset: 0x02ba
> FAT16: entry: 0x000002bb = 699, offset: 0x02bb = 699
> FAT16: ret: 0x000002bc, entry: 0x000002bb, offset: 0x02bb
> FAT16: entry: 0x000002bc = 700, offset: 0x02bc = 700
> FAT16: ret: 0x000002bd, entry: 0x000002bc, offset: 0x02bc
> FAT16: entry: 0x000002bd = 701, offset: 0x02bd = 701
> FAT16: ret: 0x000002be, entry: 0x000002bd, offset: 0x02bd
> FAT16: entry: 0x000002be = 702, offset: 0x02be = 702
> FAT16: ret: 0x000002bf, entry: 0x000002be, offset: 0x02be
> FAT16: entry: 0x000002bf = 703, offset: 0x02bf = 703
> FAT16: ret: 0x000002c0, entry: 0x000002bf, offset: 0x02bf
> FAT16: entry: 0x000002c0 = 704, offset: 0x02c0 = 704
> FAT16: ret: 0x000002c1, entry: 0x000002c0, offset: 0x02c0
> FAT16: entry: 0x000002c1 = 705, offset: 0x02c1 = 705
> FAT16: ret: 0x000002c2, entry: 0x000002c1, offset: 0x02c1
> FAT16: entry: 0x000002c2 = 706, offset: 0x02c2 = 706
> FAT16: ret: 0x000002c3, entry: 0x000002c2, offset: 0x02c2
> FAT16: entry: 0x000002c3 = 707, offset: 0x02c3 = 707
> FAT16: ret: 0x000002c4, entry: 0x000002c3, offset: 0x02c3
> FAT16: entry: 0x000002c4 = 708, offset: 0x02c4 = 708
> FAT16: ret: 0x000002c5, entry: 0x000002c4, offset: 0x02c4
> FAT16: entry: 0x000002c5 = 709, offset: 0x02c5 = 709
> FAT16: ret: 0x000002c6, entry: 0x000002c5, offset: 0x02c5
> FAT16: entry: 0x000002c6 = 710, offset: 0x02c6 = 710
> FAT16: ret: 0x000002c7, entry: 0x000002c6, offset: 0x02c6
> FAT16: entry: 0x000002c7 = 711, offset: 0x02c7 = 711
> FAT16: ret: 0x000002c8, entry: 0x000002c7, offset: 0x02c7
> FAT16: entry: 0x000002c8 = 712, offset: 0x02c8 = 712
> FAT16: ret: 0x000002c9, entry: 0x000002c8, offset: 0x02c8
> FAT16: entry: 0x000002c9 = 713, offset: 0x02c9 = 713
> FAT16: ret: 0x000002ca, entry: 0x000002c9, offset: 0x02c9
> FAT16: entry: 0x000002ca = 714, offset: 0x02ca = 714
> FAT16: ret: 0x000002cb, entry: 0x000002ca, offset: 0x02ca
> FAT16: entry: 0x000002cb = 715, offset: 0x02cb = 715
> FAT16: ret: 0x000002cc, entry: 0x000002cb, offset: 0x02cb
> FAT16: entry: 0x000002cc = 716, offset: 0x02cc = 716
> FAT16: ret: 0x000002cd, entry: 0x000002cc, offset: 0x02cc
> FAT16: entry: 0x000002cd = 717, offset: 0x02cd = 717
> FAT16: ret: 0x000002ce, entry: 0x000002cd, offset: 0x02cd
> FAT16: entry: 0x000002ce = 718, offset: 0x02ce = 718
> FAT16: ret: 0x000002ef, entry: 0x000002ce, offset: 0x02ce
> FAT16: entry: 0x000002ef = 751, offset: 0x02ef = 751
> FAT16: ret: 0x000002f0, entry: 0x000002ef, offset: 0x02ef
> FAT16: entry: 0x000002f0 = 752, offset: 0x02f0 = 752
> FAT16: ret: 0x000002f1, entry: 0x000002f0, offset: 0x02f0
> FAT16: entry: 0x000002f1 = 753, offset: 0x02f1 = 753
> FAT16: ret: 0x000002f2, entry: 0x000002f1, offset: 0x02f1
> FAT16: entry: 0x000002f2 = 754, offset: 0x02f2 = 754
> FAT16: ret: 0x000002f3, entry: 0x000002f2, offset: 0x02f2
> FAT16: entry: 0x000002f3 = 755, offset: 0x02f3 = 755
> FAT16: ret: 0x000002f4, entry: 0x000002f3, offset: 0x02f3
> FAT16: entry: 0x000002f4 = 756, offset: 0x02f4 = 756
> FAT16: ret: 0x000002f5, entry: 0x000002f4, offset: 0x02f4
> FAT16: entry: 0x000002f5 = 757, offset: 0x02f5 = 757
> FAT16: ret: 0x000002f6, entry: 0x000002f5, offset: 0x02f5
> FAT16: entry: 0x000002f6 = 758, offset: 0x02f6 = 758
> FAT16: ret: 0x000002f7, entry: 0x000002f6, offset: 0x02f6
> FAT16: entry: 0x000002f7 = 759, offset: 0x02f7 = 759
> FAT16: ret: 0x000002f8, entry: 0x000002f7, offset: 0x02f7
> FAT16: entry: 0x000002f8 = 760, offset: 0x02f8 = 760
> FAT16: ret: 0x000002f9, entry: 0x000002f8, offset: 0x02f8
> FAT16: entry: 0x000002f9 = 761, offset: 0x02f9 = 761
> FAT16: ret: 0x000002fa, entry: 0x000002f9, offset: 0x02f9
> FAT16: entry: 0x000002fa = 762, offset: 0x02fa = 762
> FAT16: ret: 0x000002fb, entry: 0x000002fa, offset: 0x02fa
> FAT16: entry: 0x000002fb = 763, offset: 0x02fb = 763
> FAT16: ret: 0x000002fc, entry: 0x000002fb, offset: 0x02fb
> FAT16: entry: 0x000002fc = 764, offset: 0x02fc = 764
> FAT16: ret: 0x000002fd, entry: 0x000002fc, offset: 0x02fc
> FAT16: entry: 0x000002fd = 765, offset: 0x02fd = 765
> FAT16: ret: 0x000002fe, entry: 0x000002fd, offset: 0x02fd
> FAT16: entry: 0x000002fe = 766, offset: 0x02fe = 766
> FAT16: ret: 0x000002ff, entry: 0x000002fe, offset: 0x02fe
> FAT16: entry: 0x000002ff = 767, offset: 0x02ff = 767
> FAT16: ret: 0x00000300, entry: 0x000002ff, offset: 0x02ff
> FAT16: entry: 0x00000300 = 768, offset: 0x0300 = 768
> FAT16: ret: 0x00000301, entry: 0x00000300, offset: 0x0300
> FAT16: entry: 0x00000301 = 769, offset: 0x0301 = 769
> FAT16: ret: 0x00000302, entry: 0x00000301, offset: 0x0301
> FAT16: entry: 0x00000302 = 770, offset: 0x0302 = 770
> FAT16: ret: 0x00000303, entry: 0x00000302, offset: 0x0302
> FAT16: entry: 0x00000303 = 771, offset: 0x0303 = 771
> FAT16: ret: 0x00000304, entry: 0x00000303, offset: 0x0303
> FAT16: entry: 0x00000304 = 772, offset: 0x0304 = 772
> FAT16: ret: 0x00000305, entry: 0x00000304, offset: 0x0304
> FAT16: entry: 0x00000305 = 773, offset: 0x0305 = 773
> FAT16: ret: 0x00000306, entry: 0x00000305, offset: 0x0305
> FAT16: entry: 0x00000306 = 774, offset: 0x0306 = 774
> FAT16: ret: 0x00000307, entry: 0x00000306, offset: 0x0306
> FAT16: entry: 0x00000307 = 775, offset: 0x0307 = 775
> FAT16: ret: 0x00000308, entry: 0x00000307, offset: 0x0307
> FAT16: entry: 0x00000308 = 776, offset: 0x0308 = 776
> FAT16: ret: 0x00000309, entry: 0x00000308, offset: 0x0308
> FAT16: entry: 0x00000309 = 777, offset: 0x0309 = 777
> FAT16: ret: 0x0000030a, entry: 0x00000309, offset: 0x0309
> FAT16: entry: 0x0000030a = 778, offset: 0x030a = 778
> FAT16: ret: 0x0000030b, entry: 0x0000030a, offset: 0x030a
> FAT16: entry: 0x0000030b = 779, offset: 0x030b = 779
> FAT16: ret: 0x0000030c, entry: 0x0000030b, offset: 0x030b
> FAT16: entry: 0x0000030c = 780, offset: 0x030c = 780
> FAT16: ret: 0x0000030d, entry: 0x0000030c, offset: 0x030c
> FAT16: entry: 0x0000030d = 781, offset: 0x030d = 781
> FAT16: ret: 0x0000030e, entry: 0x0000030d, offset: 0x030d
> FAT16: entry: 0x0000030e = 782, offset: 0x030e = 782
> FAT16: ret: 0x0000030f, entry: 0x0000030e, offset: 0x030e
> FAT16: entry: 0x0000030f = 783, offset: 0x030f = 783
> FAT16: ret: 0x00000310, entry: 0x0000030f, offset: 0x030f
> FAT16: entry: 0x00000310 = 784, offset: 0x0310 = 784
> FAT16: ret: 0x00000311, entry: 0x00000310, offset: 0x0310
> FAT16: entry: 0x00000311 = 785, offset: 0x0311 = 785
> FAT16: ret: 0x00000312, entry: 0x00000311, offset: 0x0311
> FAT16: entry: 0x00000312 = 786, offset: 0x0312 = 786
> FAT16: ret: 0x00000313, entry: 0x00000312, offset: 0x0312
> FAT16: entry: 0x00000313 = 787, offset: 0x0313 = 787
> FAT16: ret: 0x00000314, entry: 0x00000313, offset: 0x0313
> FAT16: entry: 0x00000314 = 788, offset: 0x0314 = 788
> FAT16: ret: 0x00000315, entry: 0x00000314, offset: 0x0314
> FAT16: entry: 0x00000315 = 789, offset: 0x0315 = 789
> FAT16: ret: 0x00000316, entry: 0x00000315, offset: 0x0315
> FAT16: entry: 0x00000316 = 790, offset: 0x0316 = 790
> FAT16: ret: 0x00000317, entry: 0x00000316, offset: 0x0316
> FAT16: entry: 0x00000317 = 791, offset: 0x0317 = 791
> FAT16: ret: 0x00000318, entry: 0x00000317, offset: 0x0317
> FAT16: entry: 0x00000318 = 792, offset: 0x0318 = 792
> FAT16: ret: 0x00000319, entry: 0x00000318, offset: 0x0318
> FAT16: entry: 0x00000319 = 793, offset: 0x0319 = 793
> FAT16: ret: 0x0000031a, entry: 0x00000319, offset: 0x0319
> FAT16: entry: 0x0000031a = 794, offset: 0x031a = 794
> FAT16: ret: 0x0000031b, entry: 0x0000031a, offset: 0x031a
> FAT16: entry: 0x0000031b = 795, offset: 0x031b = 795
> FAT16: ret: 0x0000031c, entry: 0x0000031b, offset: 0x031b
> FAT16: entry: 0x0000031c = 796, offset: 0x031c = 796
> FAT16: ret: 0x0000031d, entry: 0x0000031c, offset: 0x031c
> FAT16: entry: 0x0000031d = 797, offset: 0x031d = 797
> FAT16: ret: 0x0000031e, entry: 0x0000031d, offset: 0x031d
> FAT16: entry: 0x0000031e = 798, offset: 0x031e = 798
> FAT16: ret: 0x0000031f, entry: 0x0000031e, offset: 0x031e
> FAT16: entry: 0x0000031f = 799, offset: 0x031f = 799
> FAT16: ret: 0x00000320, entry: 0x0000031f, offset: 0x031f
> FAT16: entry: 0x00000320 = 800, offset: 0x0320 = 800
> FAT16: ret: 0x00000321, entry: 0x00000320, offset: 0x0320
> FAT16: entry: 0x00000321 = 801, offset: 0x0321 = 801
> FAT16: ret: 0x00000322, entry: 0x00000321, offset: 0x0321
> FAT16: entry: 0x00000322 = 802, offset: 0x0322 = 802
> FAT16: ret: 0x00000323, entry: 0x00000322, offset: 0x0322
> FAT16: entry: 0x00000323 = 803, offset: 0x0323 = 803
> FAT16: ret: 0x00000324, entry: 0x00000323, offset: 0x0323
> FAT16: entry: 0x00000324 = 804, offset: 0x0324 = 804
> FAT16: ret: 0x00000325, entry: 0x00000324, offset: 0x0324
> FAT16: entry: 0x00000325 = 805, offset: 0x0325 = 805
> FAT16: ret: 0x00000326, entry: 0x00000325, offset: 0x0325
> FAT16: entry: 0x00000326 = 806, offset: 0x0326 = 806
> FAT16: ret: 0x00000327, entry: 0x00000326, offset: 0x0326
> FAT16: entry: 0x00000327 = 807, offset: 0x0327 = 807
> FAT16: ret: 0x00000328, entry: 0x00000327, offset: 0x0327
> FAT16: entry: 0x00000328 = 808, offset: 0x0328 = 808
> FAT16: ret: 0x00000329, entry: 0x00000328, offset: 0x0328
> FAT16: entry: 0x00000329 = 809, offset: 0x0329 = 809
> FAT16: ret: 0x0000032a, entry: 0x00000329, offset: 0x0329
> FAT16: entry: 0x0000032a = 810, offset: 0x032a = 810
> FAT16: ret: 0x0000032b, entry: 0x0000032a, offset: 0x032a
> FAT16: entry: 0x0000032b = 811, offset: 0x032b = 811
> FAT16: ret: 0x0000032c, entry: 0x0000032b, offset: 0x032b
> FAT16: entry: 0x0000032c = 812, offset: 0x032c = 812
> FAT16: ret: 0x0000032d, entry: 0x0000032c, offset: 0x032c
> FAT16: entry: 0x0000032d = 813, offset: 0x032d = 813
> FAT16: ret: 0x0000032e, entry: 0x0000032d, offset: 0x032d
> FAT16: entry: 0x0000032e = 814, offset: 0x032e = 814
> FAT16: ret: 0x0000032f, entry: 0x0000032e, offset: 0x032e
> FAT16: entry: 0x0000032f = 815, offset: 0x032f = 815
> FAT16: ret: 0x00000330, entry: 0x0000032f, offset: 0x032f
> FAT16: entry: 0x00000330 = 816, offset: 0x0330 = 816
> FAT16: ret: 0x00000331, entry: 0x00000330, offset: 0x0330
> FAT16: entry: 0x00000331 = 817, offset: 0x0331 = 817
> FAT16: ret: 0x00000332, entry: 0x00000331, offset: 0x0331
> FAT16: entry: 0x00000332 = 818, offset: 0x0332 = 818
> FAT16: ret: 0x00000333, entry: 0x00000332, offset: 0x0332
> FAT16: entry: 0x00000333 = 819, offset: 0x0333 = 819
> FAT16: ret: 0x00000334, entry: 0x00000333, offset: 0x0333
> FAT16: entry: 0x00000334 = 820, offset: 0x0334 = 820
> FAT16: ret: 0x00000335, entry: 0x00000334, offset: 0x0334
> FAT16: entry: 0x00000335 = 821, offset: 0x0335 = 821
> FAT16: ret: 0x00000336, entry: 0x00000335, offset: 0x0335
> FAT16: entry: 0x00000336 = 822, offset: 0x0336 = 822
> FAT16: ret: 0x00000337, entry: 0x00000336, offset: 0x0336
> FAT16: entry: 0x00000337 = 823, offset: 0x0337 = 823
> FAT16: ret: 0x00000338, entry: 0x00000337, offset: 0x0337
> FAT16: entry: 0x00000338 = 824, offset: 0x0338 = 824
> FAT16: ret: 0x00000339, entry: 0x00000338, offset: 0x0338
> FAT16: entry: 0x00000339 = 825, offset: 0x0339 = 825
> FAT16: ret: 0x0000033a, entry: 0x00000339, offset: 0x0339
> FAT16: entry: 0x0000033a = 826, offset: 0x033a = 826
> FAT16: ret: 0x0000033b, entry: 0x0000033a, offset: 0x033a
> FAT16: entry: 0x0000033b = 827, offset: 0x033b = 827
> FAT16: ret: 0x0000033c, entry: 0x0000033b, offset: 0x033b
> FAT16: entry: 0x0000033c = 828, offset: 0x033c = 828
> FAT16: ret: 0x0000033d, entry: 0x0000033c, offset: 0x033c
> FAT16: entry: 0x0000033d = 829, offset: 0x033d = 829
> FAT16: ret: 0x0000033e, entry: 0x0000033d, offset: 0x033d
> FAT16: entry: 0x0000033e = 830, offset: 0x033e = 830
> FAT16: ret: 0x0000033f, entry: 0x0000033e, offset: 0x033e
> FAT16: entry: 0x0000033f = 831, offset: 0x033f = 831
> FAT16: ret: 0x00000340, entry: 0x0000033f, offset: 0x033f
> FAT16: entry: 0x00000340 = 832, offset: 0x0340 = 832
> FAT16: ret: 0x00000341, entry: 0x00000340, offset: 0x0340
> FAT16: entry: 0x00000341 = 833, offset: 0x0341 = 833
> FAT16: ret: 0x00000342, entry: 0x00000341, offset: 0x0341
> FAT16: entry: 0x00000342 = 834, offset: 0x0342 = 834
> FAT16: ret: 0x00000343, entry: 0x00000342, offset: 0x0342
> FAT16: entry: 0x00000343 = 835, offset: 0x0343 = 835
> FAT16: ret: 0x00000344, entry: 0x00000343, offset: 0x0343
> FAT16: entry: 0x00000344 = 836, offset: 0x0344 = 836
> FAT16: ret: 0x00000345, entry: 0x00000344, offset: 0x0344
> FAT16: entry: 0x00000345 = 837, offset: 0x0345 = 837
> FAT16: ret: 0x00000346, entry: 0x00000345, offset: 0x0345
> FAT16: entry: 0x00000346 = 838, offset: 0x0346 = 838
> FAT16: ret: 0x00000347, entry: 0x00000346, offset: 0x0346
> FAT16: entry: 0x00000347 = 839, offset: 0x0347 = 839
> FAT16: ret: 0x00000348, entry: 0x00000347, offset: 0x0347
> FAT16: entry: 0x00000348 = 840, offset: 0x0348 = 840
> FAT16: ret: 0x00000349, entry: 0x00000348, offset: 0x0348
> FAT16: entry: 0x00000349 = 841, offset: 0x0349 = 841
> FAT16: ret: 0x0000034a, entry: 0x00000349, offset: 0x0349
> FAT16: entry: 0x0000034a = 842, offset: 0x034a = 842
> FAT16: ret: 0x0000034b, entry: 0x0000034a, offset: 0x034a
> FAT16: entry: 0x0000034b = 843, offset: 0x034b = 843
> FAT16: ret: 0x0000034c, entry: 0x0000034b, offset: 0x034b
> FAT16: entry: 0x0000034c = 844, offset: 0x034c = 844
> FAT16: ret: 0x0000034d, entry: 0x0000034c, offset: 0x034c
> FAT16: entry: 0x0000034d = 845, offset: 0x034d = 845
> FAT16: ret: 0x0000034e, entry: 0x0000034d, offset: 0x034d
> FAT16: entry: 0x0000034e = 846, offset: 0x034e = 846
> FAT16: ret: 0x0000034f, entry: 0x0000034e, offset: 0x034e
> FAT16: entry: 0x0000034f = 847, offset: 0x034f = 847
> FAT16: ret: 0x00000350, entry: 0x0000034f, offset: 0x034f
> FAT16: entry: 0x00000350 = 848, offset: 0x0350 = 848
> FAT16: ret: 0x00000351, entry: 0x00000350, offset: 0x0350
> FAT16: entry: 0x00000351 = 849, offset: 0x0351 = 849
> FAT16: ret: 0x00000352, entry: 0x00000351, offset: 0x0351
> FAT16: entry: 0x00000352 = 850, offset: 0x0352 = 850
> FAT16: ret: 0x00000353, entry: 0x00000352, offset: 0x0352
> FAT16: entry: 0x00000353 = 851, offset: 0x0353 = 851
> FAT16: ret: 0x00000354, entry: 0x00000353, offset: 0x0353
> FAT16: entry: 0x00000354 = 852, offset: 0x0354 = 852
> FAT16: ret: 0x00000355, entry: 0x00000354, offset: 0x0354
> FAT16: entry: 0x00000355 = 853, offset: 0x0355 = 853
> FAT16: ret: 0x00000356, entry: 0x00000355, offset: 0x0355
> FAT16: entry: 0x00000356 = 854, offset: 0x0356 = 854
> FAT16: ret: 0x00000357, entry: 0x00000356, offset: 0x0356
> FAT16: entry: 0x00000357 = 855, offset: 0x0357 = 855
> FAT16: ret: 0x00000358, entry: 0x00000357, offset: 0x0357
> FAT16: entry: 0x00000358 = 856, offset: 0x0358 = 856
> FAT16: ret: 0x00000359, entry: 0x00000358, offset: 0x0358
> FAT16: entry: 0x00000359 = 857, offset: 0x0359 = 857
> FAT16: ret: 0x0000035a, entry: 0x00000359, offset: 0x0359
> FAT16: entry: 0x0000035a = 858, offset: 0x035a = 858
> FAT16: ret: 0x0000035b, entry: 0x0000035a, offset: 0x035a
> FAT16: entry: 0x0000035b = 859, offset: 0x035b = 859
> FAT16: ret: 0x0000035c, entry: 0x0000035b, offset: 0x035b
> FAT16: entry: 0x0000035c = 860, offset: 0x035c = 860
> FAT16: ret: 0x0000035d, entry: 0x0000035c, offset: 0x035c
> FAT16: entry: 0x0000035d = 861, offset: 0x035d = 861
> FAT16: ret: 0x0000035e, entry: 0x0000035d, offset: 0x035d
> FAT16: entry: 0x0000035e = 862, offset: 0x035e = 862
> FAT16: ret: 0x0000035f, entry: 0x0000035e, offset: 0x035e
> FAT16: entry: 0x0000035f = 863, offset: 0x035f = 863
> FAT16: ret: 0x00000360, entry: 0x0000035f, offset: 0x035f
> FAT16: entry: 0x00000360 = 864, offset: 0x0360 = 864
> FAT16: ret: 0x00000361, entry: 0x00000360, offset: 0x0360
> FAT16: entry: 0x00000361 = 865, offset: 0x0361 = 865
> FAT16: ret: 0x00000362, entry: 0x00000361, offset: 0x0361
> FAT16: entry: 0x00000362 = 866, offset: 0x0362 = 866
> FAT16: ret: 0x00000363, entry: 0x00000362, offset: 0x0362
> FAT16: entry: 0x00000363 = 867, offset: 0x0363 = 867
> FAT16: ret: 0x00000364, entry: 0x00000363, offset: 0x0363
> FAT16: entry: 0x00000364 = 868, offset: 0x0364 = 868
> FAT16: ret: 0x00000365, entry: 0x00000364, offset: 0x0364
> FAT16: entry: 0x00000365 = 869, offset: 0x0365 = 869
> FAT16: ret: 0x00000366, entry: 0x00000365, offset: 0x0365
> FAT16: entry: 0x00000366 = 870, offset: 0x0366 = 870
> FAT16: ret: 0x00000367, entry: 0x00000366, offset: 0x0366
> FAT16: entry: 0x00000367 = 871, offset: 0x0367 = 871
> FAT16: ret: 0x00000368, entry: 0x00000367, offset: 0x0367
> FAT16: entry: 0x00000368 = 872, offset: 0x0368 = 872
> FAT16: ret: 0x00000369, entry: 0x00000368, offset: 0x0368
> FAT16: entry: 0x00000369 = 873, offset: 0x0369 = 873
> FAT16: ret: 0x0000036a, entry: 0x00000369, offset: 0x0369
> FAT16: entry: 0x0000036a = 874, offset: 0x036a = 874
> FAT16: ret: 0x0000036b, entry: 0x0000036a, offset: 0x036a
> FAT16: entry: 0x0000036b = 875, offset: 0x036b = 875
> FAT16: ret: 0x0000036c, entry: 0x0000036b, offset: 0x036b
> FAT16: entry: 0x0000036c = 876, offset: 0x036c = 876
> FAT16: ret: 0x0000036d, entry: 0x0000036c, offset: 0x036c
> FAT16: entry: 0x0000036d = 877, offset: 0x036d = 877
> FAT16: ret: 0x0000036e, entry: 0x0000036d, offset: 0x036d
> FAT16: entry: 0x0000036e = 878, offset: 0x036e = 878
> FAT16: ret: 0x0000036f, entry: 0x0000036e, offset: 0x036e
> FAT16: entry: 0x0000036f = 879, offset: 0x036f = 879
> FAT16: ret: 0x00000370, entry: 0x0000036f, offset: 0x036f
> FAT16: entry: 0x00000370 = 880, offset: 0x0370 = 880
> FAT16: ret: 0x00000371, entry: 0x00000370, offset: 0x0370
> FAT16: entry: 0x00000371 = 881, offset: 0x0371 = 881
> FAT16: ret: 0x00000372, entry: 0x00000371, offset: 0x0371
> FAT16: entry: 0x00000372 = 882, offset: 0x0372 = 882
> FAT16: ret: 0x00000373, entry: 0x00000372, offset: 0x0372
> FAT16: entry: 0x00000373 = 883, offset: 0x0373 = 883
> FAT16: ret: 0x00000374, entry: 0x00000373, offset: 0x0373
> FAT16: entry: 0x00000374 = 884, offset: 0x0374 = 884
> FAT16: ret: 0x00000375, entry: 0x00000374, offset: 0x0374
> FAT16: entry: 0x00000375 = 885, offset: 0x0375 = 885
> FAT16: ret: 0x00000376, entry: 0x00000375, offset: 0x0375
> FAT16: entry: 0x00000376 = 886, offset: 0x0376 = 886
> FAT16: ret: 0x00000377, entry: 0x00000376, offset: 0x0376
> FAT16: entry: 0x00000377 = 887, offset: 0x0377 = 887
> FAT16: ret: 0x00000378, entry: 0x00000377, offset: 0x0377
> FAT16: entry: 0x00000378 = 888, offset: 0x0378 = 888
> FAT16: ret: 0x00000379, entry: 0x00000378, offset: 0x0378
> FAT16: entry: 0x00000379 = 889, offset: 0x0379 = 889
> FAT16: ret: 0x0000037a, entry: 0x00000379, offset: 0x0379
> FAT16: entry: 0x0000037a = 890, offset: 0x037a = 890
> FAT16: ret: 0x0000037b, entry: 0x0000037a, offset: 0x037a
> FAT16: entry: 0x0000037b = 891, offset: 0x037b = 891
> FAT16: ret: 0x0000037c, entry: 0x0000037b, offset: 0x037b
> FAT16: entry: 0x0000037c = 892, offset: 0x037c = 892
> FAT16: ret: 0x0000037d, entry: 0x0000037c, offset: 0x037c
> FAT16: entry: 0x0000037d = 893, offset: 0x037d = 893
> FAT16: ret: 0x0000037e, entry: 0x0000037d, offset: 0x037d
> FAT16: entry: 0x0000037e = 894, offset: 0x037e = 894
> FAT16: ret: 0x0000037f, entry: 0x0000037e, offset: 0x037e
> FAT16: entry: 0x0000037f = 895, offset: 0x037f = 895
> FAT16: ret: 0x00000380, entry: 0x0000037f, offset: 0x037f
> FAT16: entry: 0x00000380 = 896, offset: 0x0380 = 896
> FAT16: ret: 0x00000381, entry: 0x00000380, offset: 0x0380
> FAT16: entry: 0x00000381 = 897, offset: 0x0381 = 897
> FAT16: ret: 0x00000382, entry: 0x00000381, offset: 0x0381
> FAT16: entry: 0x00000382 = 898, offset: 0x0382 = 898
> FAT16: ret: 0x00000383, entry: 0x00000382, offset: 0x0382
> FAT16: entry: 0x00000383 = 899, offset: 0x0383 = 899
> FAT16: ret: 0x00000384, entry: 0x00000383, offset: 0x0383
> FAT16: entry: 0x00000384 = 900, offset: 0x0384 = 900
> FAT16: ret: 0x00000385, entry: 0x00000384, offset: 0x0384
> FAT16: entry: 0x00000385 = 901, offset: 0x0385 = 901
> FAT16: ret: 0x00000386, entry: 0x00000385, offset: 0x0385
> FAT16: entry: 0x00000386 = 902, offset: 0x0386 = 902
> FAT16: ret: 0x00000387, entry: 0x00000386, offset: 0x0386
> FAT16: entry: 0x00000387 = 903, offset: 0x0387 = 903
> FAT16: ret: 0x00000388, entry: 0x00000387, offset: 0x0387
> FAT16: entry: 0x00000388 = 904, offset: 0x0388 = 904
> FAT16: ret: 0x00000389, entry: 0x00000388, offset: 0x0388
> FAT16: entry: 0x00000389 = 905, offset: 0x0389 = 905
> FAT16: ret: 0x0000038a, entry: 0x00000389, offset: 0x0389
> FAT16: entry: 0x0000038a = 906, offset: 0x038a = 906
> FAT16: ret: 0x0000038b, entry: 0x0000038a, offset: 0x038a
> FAT16: entry: 0x0000038b = 907, offset: 0x038b = 907
> FAT16: ret: 0x0000038c, entry: 0x0000038b, offset: 0x038b
> FAT16: entry: 0x0000038c = 908, offset: 0x038c = 908
> FAT16: ret: 0x0000038d, entry: 0x0000038c, offset: 0x038c
> FAT16: entry: 0x0000038d = 909, offset: 0x038d = 909
> FAT16: ret: 0x0000038e, entry: 0x0000038d, offset: 0x038d
> FAT16: entry: 0x0000038e = 910, offset: 0x038e = 910
> FAT16: ret: 0x0000038f, entry: 0x0000038e, offset: 0x038e
> FAT16: entry: 0x0000038f = 911, offset: 0x038f = 911
> FAT16: ret: 0x00000390, entry: 0x0000038f, offset: 0x038f
> FAT16: entry: 0x00000390 = 912, offset: 0x0390 = 912
> FAT16: ret: 0x00000391, entry: 0x00000390, offset: 0x0390
> FAT16: entry: 0x00000391 = 913, offset: 0x0391 = 913
> FAT16: ret: 0x00000392, entry: 0x00000391, offset: 0x0391
> FAT16: entry: 0x00000392 = 914, offset: 0x0392 = 914
> FAT16: ret: 0x00000393, entry: 0x00000392, offset: 0x0392
> FAT16: entry: 0x00000393 = 915, offset: 0x0393 = 915
> FAT16: ret: 0x00000394, entry: 0x00000393, offset: 0x0393
> FAT16: entry: 0x00000394 = 916, offset: 0x0394 = 916
> FAT16: ret: 0x00000395, entry: 0x00000394, offset: 0x0394
> FAT16: entry: 0x00000395 = 917, offset: 0x0395 = 917
> FAT16: ret: 0x00000396, entry: 0x00000395, offset: 0x0395
> FAT16: entry: 0x00000396 = 918, offset: 0x0396 = 918
> FAT16: ret: 0x00000397, entry: 0x00000396, offset: 0x0396
> FAT16: entry: 0x00000397 = 919, offset: 0x0397 = 919
> FAT16: ret: 0x00000398, entry: 0x00000397, offset: 0x0397
> FAT16: entry: 0x00000398 = 920, offset: 0x0398 = 920
> FAT16: ret: 0x00000399, entry: 0x00000398, offset: 0x0398
> FAT16: entry: 0x00000399 = 921, offset: 0x0399 = 921
> FAT16: ret: 0x0000039a, entry: 0x00000399, offset: 0x0399
> FAT16: entry: 0x0000039a = 922, offset: 0x039a = 922
> FAT16: ret: 0x0000039b, entry: 0x0000039a, offset: 0x039a
> FAT16: entry: 0x0000039b = 923, offset: 0x039b = 923
> FAT16: ret: 0x0000039c, entry: 0x0000039b, offset: 0x039b
> FAT16: entry: 0x0000039c = 924, offset: 0x039c = 924
> FAT16: ret: 0x0000039d, entry: 0x0000039c, offset: 0x039c
> FAT16: entry: 0x0000039d = 925, offset: 0x039d = 925
> FAT16: ret: 0x0000039e, entry: 0x0000039d, offset: 0x039d
> FAT16: entry: 0x0000039e = 926, offset: 0x039e = 926
> FAT16: ret: 0x0000039f, entry: 0x0000039e, offset: 0x039e
> FAT16: entry: 0x0000039f = 927, offset: 0x039f = 927
> FAT16: ret: 0x000003a0, entry: 0x0000039f, offset: 0x039f
> FAT16: entry: 0x000003a0 = 928, offset: 0x03a0 = 928
> FAT16: ret: 0x000003a1, entry: 0x000003a0, offset: 0x03a0
> FAT16: entry: 0x000003a1 = 929, offset: 0x03a1 = 929
> FAT16: ret: 0x000003a2, entry: 0x000003a1, offset: 0x03a1
> FAT16: entry: 0x000003a2 = 930, offset: 0x03a2 = 930
> FAT16: ret: 0x000003a3, entry: 0x000003a2, offset: 0x03a2
> FAT16: entry: 0x000003a3 = 931, offset: 0x03a3 = 931
> FAT16: ret: 0x000003a4, entry: 0x000003a3, offset: 0x03a3
> FAT16: entry: 0x000003a4 = 932, offset: 0x03a4 = 932
> FAT16: ret: 0x000003a5, entry: 0x000003a4, offset: 0x03a4
> FAT16: entry: 0x000003a5 = 933, offset: 0x03a5 = 933
> FAT16: ret: 0x000003a6, entry: 0x000003a5, offset: 0x03a5
> FAT16: entry: 0x000003a6 = 934, offset: 0x03a6 = 934
> FAT16: ret: 0x000003a7, entry: 0x000003a6, offset: 0x03a6
> FAT16: entry: 0x000003a7 = 935, offset: 0x03a7 = 935
> FAT16: ret: 0x000003a8, entry: 0x000003a7, offset: 0x03a7
> FAT16: entry: 0x000003a8 = 936, offset: 0x03a8 = 936
> FAT16: ret: 0x000003a9, entry: 0x000003a8, offset: 0x03a8
> FAT16: entry: 0x000003a9 = 937, offset: 0x03a9 = 937
> FAT16: ret: 0x000003aa, entry: 0x000003a9, offset: 0x03a9
> FAT16: entry: 0x000003aa = 938, offset: 0x03aa = 938
> FAT16: ret: 0x000003ab, entry: 0x000003aa, offset: 0x03aa
> FAT16: entry: 0x000003ab = 939, offset: 0x03ab = 939
> FAT16: ret: 0x000003ac, entry: 0x000003ab, offset: 0x03ab
> FAT16: entry: 0x000003ac = 940, offset: 0x03ac = 940
> FAT16: ret: 0x000003ad, entry: 0x000003ac, offset: 0x03ac
> FAT16: entry: 0x000003ad = 941, offset: 0x03ad = 941
> FAT16: ret: 0x000003ae, entry: 0x000003ad, offset: 0x03ad
> FAT16: entry: 0x000003ae = 942, offset: 0x03ae = 942
> FAT16: ret: 0x000003af, entry: 0x000003ae, offset: 0x03ae
> FAT16: entry: 0x000003af = 943, offset: 0x03af = 943
> FAT16: ret: 0x000003b0, entry: 0x000003af, offset: 0x03af
> FAT16: entry: 0x000003b0 = 944, offset: 0x03b0 = 944
> FAT16: ret: 0x000003b1, entry: 0x000003b0, offset: 0x03b0
> FAT16: entry: 0x000003b1 = 945, offset: 0x03b1 = 945
> FAT16: ret: 0x000003b2, entry: 0x000003b1, offset: 0x03b1
> FAT16: entry: 0x000003b2 = 946, offset: 0x03b2 = 946
> FAT16: ret: 0x000003b3, entry: 0x000003b2, offset: 0x03b2
> FAT16: entry: 0x000003b3 = 947, offset: 0x03b3 = 947
> FAT16: ret: 0x000003b4, entry: 0x000003b3, offset: 0x03b3
> FAT16: entry: 0x000003b4 = 948, offset: 0x03b4 = 948
> FAT16: ret: 0x000003b5, entry: 0x000003b4, offset: 0x03b4
> FAT16: entry: 0x000003b5 = 949, offset: 0x03b5 = 949
> FAT16: ret: 0x000003b6, entry: 0x000003b5, offset: 0x03b5
> FAT16: entry: 0x000003b6 = 950, offset: 0x03b6 = 950
> FAT16: ret: 0x000003b7, entry: 0x000003b6, offset: 0x03b6
> FAT16: entry: 0x000003b7 = 951, offset: 0x03b7 = 951
> FAT16: ret: 0x000003b8, entry: 0x000003b7, offset: 0x03b7
> FAT16: entry: 0x000003b8 = 952, offset: 0x03b8 = 952
> FAT16: ret: 0x000003b9, entry: 0x000003b8, offset: 0x03b8
> FAT16: entry: 0x000003b9 = 953, offset: 0x03b9 = 953
> FAT16: ret: 0x000003ba, entry: 0x000003b9, offset: 0x03b9
> FAT16: entry: 0x000003ba = 954, offset: 0x03ba = 954
> FAT16: ret: 0x000003bb, entry: 0x000003ba, offset: 0x03ba
> FAT16: entry: 0x000003bb = 955, offset: 0x03bb = 955
> FAT16: ret: 0x000003bc, entry: 0x000003bb, offset: 0x03bb
> FAT16: entry: 0x000003bc = 956, offset: 0x03bc = 956
> FAT16: ret: 0x000003bd, entry: 0x000003bc, offset: 0x03bc
> FAT16: entry: 0x000003bd = 957, offset: 0x03bd = 957
> FAT16: ret: 0x000003be, entry: 0x000003bd, offset: 0x03bd
> FAT16: entry: 0x000003be = 958, offset: 0x03be = 958
> FAT16: ret: 0x000003bf, entry: 0x000003be, offset: 0x03be
> FAT16: entry: 0x000003bf = 959, offset: 0x03bf = 959
> FAT16: ret: 0x000003c0, entry: 0x000003bf, offset: 0x03bf
> FAT16: entry: 0x000003c0 = 960, offset: 0x03c0 = 960
> FAT16: ret: 0x000003c1, entry: 0x000003c0, offset: 0x03c0
> FAT16: entry: 0x000003c1 = 961, offset: 0x03c1 = 961
> FAT16: ret: 0x000003c2, entry: 0x000003c1, offset: 0x03c1
> FAT16: entry: 0x000003c2 = 962, offset: 0x03c2 = 962
> FAT16: ret: 0x000003c3, entry: 0x000003c2, offset: 0x03c2
> FAT16: entry: 0x000003c3 = 963, offset: 0x03c3 = 963
> FAT16: ret: 0x000003c4, entry: 0x000003c3, offset: 0x03c3
> FAT16: entry: 0x000003c4 = 964, offset: 0x03c4 = 964
> FAT16: ret: 0x000003c5, entry: 0x000003c4, offset: 0x03c4
> FAT16: entry: 0x000003c5 = 965, offset: 0x03c5 = 965
> FAT16: ret: 0x000003c6, entry: 0x000003c5, offset: 0x03c5
> FAT16: entry: 0x000003c6 = 966, offset: 0x03c6 = 966
> FAT16: ret: 0x000003c7, entry: 0x000003c6, offset: 0x03c6
> FAT16: entry: 0x000003c7 = 967, offset: 0x03c7 = 967
> FAT16: ret: 0x000003c8, entry: 0x000003c7, offset: 0x03c7
> FAT16: entry: 0x000003c8 = 968, offset: 0x03c8 = 968
> FAT16: ret: 0x000003c9, entry: 0x000003c8, offset: 0x03c8
> FAT16: entry: 0x000003c9 = 969, offset: 0x03c9 = 969
> FAT16: ret: 0x000003ca, entry: 0x000003c9, offset: 0x03c9
> FAT16: entry: 0x000003ca = 970, offset: 0x03ca = 970
> FAT16: ret: 0x000003cb, entry: 0x000003ca, offset: 0x03ca
> FAT16: entry: 0x000003cb = 971, offset: 0x03cb = 971
> FAT16: ret: 0x000003cc, entry: 0x000003cb, offset: 0x03cb
> FAT16: entry: 0x000003cc = 972, offset: 0x03cc = 972
> FAT16: ret: 0x000003cd, entry: 0x000003cc, offset: 0x03cc
> FAT16: entry: 0x000003cd = 973, offset: 0x03cd = 973
> FAT16: ret: 0x000003ce, entry: 0x000003cd, offset: 0x03cd
> FAT16: entry: 0x000003ce = 974, offset: 0x03ce = 974
> FAT16: ret: 0x000003cf, entry: 0x000003ce, offset: 0x03ce
> FAT16: entry: 0x000003cf = 975, offset: 0x03cf = 975
> FAT16: ret: 0x000003d0, entry: 0x000003cf, offset: 0x03cf
> FAT16: entry: 0x000003d0 = 976, offset: 0x03d0 = 976
> FAT16: ret: 0x000003d1, entry: 0x000003d0, offset: 0x03d0
> FAT16: entry: 0x000003d1 = 977, offset: 0x03d1 = 977
> FAT16: ret: 0x000003d2, entry: 0x000003d1, offset: 0x03d1
> FAT16: entry: 0x000003d2 = 978, offset: 0x03d2 = 978
> FAT16: ret: 0x000003d3, entry: 0x000003d2, offset: 0x03d2
> FAT16: entry: 0x000003d3 = 979, offset: 0x03d3 = 979
> FAT16: ret: 0x000003d4, entry: 0x000003d3, offset: 0x03d3
> FAT16: entry: 0x000003d4 = 980, offset: 0x03d4 = 980
> FAT16: ret: 0x000003d5, entry: 0x000003d4, offset: 0x03d4
> FAT16: entry: 0x000003d5 = 981, offset: 0x03d5 = 981
> FAT16: ret: 0x000003d6, entry: 0x000003d5, offset: 0x03d5
> FAT16: entry: 0x000003d6 = 982, offset: 0x03d6 = 982
> FAT16: ret: 0x000003d7, entry: 0x000003d6, offset: 0x03d6
> FAT16: entry: 0x000003d7 = 983, offset: 0x03d7 = 983
> FAT16: ret: 0x000003d8, entry: 0x000003d7, offset: 0x03d7
> FAT16: entry: 0x000003d8 = 984, offset: 0x03d8 = 984
> FAT16: ret: 0x000003d9, entry: 0x000003d8, offset: 0x03d8
> FAT16: entry: 0x000003d9 = 985, offset: 0x03d9 = 985
> FAT16: ret: 0x000003da, entry: 0x000003d9, offset: 0x03d9
> FAT16: entry: 0x000003da = 986, offset: 0x03da = 986
> FAT16: ret: 0x000003db, entry: 0x000003da, offset: 0x03da
> FAT16: entry: 0x000003db = 987, offset: 0x03db = 987
> FAT16: ret: 0x000003dc, entry: 0x000003db, offset: 0x03db
> FAT16: entry: 0x000003dc = 988, offset: 0x03dc = 988
> FAT16: ret: 0x000003dd, entry: 0x000003dc, offset: 0x03dc
> FAT16: entry: 0x000003dd = 989, offset: 0x03dd = 989
> FAT16: ret: 0x000003de, entry: 0x000003dd, offset: 0x03dd
> FAT16: entry: 0x000003de = 990, offset: 0x03de = 990
> FAT16: ret: 0x000003df, entry: 0x000003de, offset: 0x03de
> FAT16: entry: 0x000003df = 991, offset: 0x03df = 991
> FAT16: ret: 0x000003e0, entry: 0x000003df, offset: 0x03df
> FAT16: entry: 0x000003e0 = 992, offset: 0x03e0 = 992
> FAT16: ret: 0x000003e1, entry: 0x000003e0, offset: 0x03e0
> FAT16: entry: 0x000003e1 = 993, offset: 0x03e1 = 993
> FAT16: ret: 0x000003e2, entry: 0x000003e1, offset: 0x03e1
> FAT16: entry: 0x000003e2 = 994, offset: 0x03e2 = 994
> FAT16: ret: 0x000003e3, entry: 0x000003e2, offset: 0x03e2
> FAT16: entry: 0x000003e3 = 995, offset: 0x03e3 = 995
> FAT16: ret: 0x000003e4, entry: 0x000003e3, offset: 0x03e3
> FAT16: entry: 0x000003e4 = 996, offset: 0x03e4 = 996
> FAT16: ret: 0x000003e5, entry: 0x000003e4, offset: 0x03e4
> FAT16: entry: 0x000003e5 = 997, offset: 0x03e5 = 997
> FAT16: ret: 0x000003e6, entry: 0x000003e5, offset: 0x03e5
> FAT16: entry: 0x000003e6 = 998, offset: 0x03e6 = 998
> FAT16: ret: 0x000003e7, entry: 0x000003e6, offset: 0x03e6
> FAT16: entry: 0x000003e7 = 999, offset: 0x03e7 = 999
> FAT16: ret: 0x000003e8, entry: 0x000003e7, offset: 0x03e7
> FAT16: entry: 0x000003e8 = 1000, offset: 0x03e8 = 1000
> FAT16: ret: 0x000003e9, entry: 0x000003e8, offset: 0x03e8
> FAT16: entry: 0x000003e9 = 1001, offset: 0x03e9 = 1001
> FAT16: ret: 0x000003ea, entry: 0x000003e9, offset: 0x03e9
> FAT16: entry: 0x000003ea = 1002, offset: 0x03ea = 1002
> FAT16: ret: 0x000003eb, entry: 0x000003ea, offset: 0x03ea
> FAT16: entry: 0x000003eb = 1003, offset: 0x03eb = 1003
> FAT16: ret: 0x000003ec, entry: 0x000003eb, offset: 0x03eb
> FAT16: entry: 0x000003ec = 1004, offset: 0x03ec = 1004
> FAT16: ret: 0x000003ed, entry: 0x000003ec, offset: 0x03ec
> FAT16: entry: 0x000003ed = 1005, offset: 0x03ed = 1005
> FAT16: ret: 0x000003ee, entry: 0x000003ed, offset: 0x03ed
> FAT16: entry: 0x000003ee = 1006, offset: 0x03ee = 1006
> FAT16: ret: 0x000003ef, entry: 0x000003ee, offset: 0x03ee
> FAT16: entry: 0x000003ef = 1007, offset: 0x03ef = 1007
> FAT16: ret: 0x000003f0, entry: 0x000003ef, offset: 0x03ef
> FAT16: entry: 0x000003f0 = 1008, offset: 0x03f0 = 1008
> FAT16: ret: 0x000003f1, entry: 0x000003f0, offset: 0x03f0
> FAT16: entry: 0x000003f1 = 1009, offset: 0x03f1 = 1009
> FAT16: ret: 0x000003f2, entry: 0x000003f1, offset: 0x03f1
> FAT16: entry: 0x000003f2 = 1010, offset: 0x03f2 = 1010
> FAT16: ret: 0x000003f3, entry: 0x000003f2, offset: 0x03f2
> FAT16: entry: 0x000003f3 = 1011, offset: 0x03f3 = 1011
> FAT16: ret: 0x000003f4, entry: 0x000003f3, offset: 0x03f3
> FAT16: entry: 0x000003f4 = 1012, offset: 0x03f4 = 1012
> FAT16: ret: 0x000003f5, entry: 0x000003f4, offset: 0x03f4
> FAT16: entry: 0x000003f5 = 1013, offset: 0x03f5 = 1013
> FAT16: ret: 0x000003f6, entry: 0x000003f5, offset: 0x03f5
> FAT16: entry: 0x000003f6 = 1014, offset: 0x03f6 = 1014
> FAT16: ret: 0x000005f7, entry: 0x000003f6, offset: 0x03f6
> FAT16: entry: 0x000005f7 = 1527, offset: 0x05f7 = 1527
> FAT16: ret: 0x000005f8, entry: 0x000005f7, offset: 0x05f7
> FAT16: entry: 0x000005f8 = 1528, offset: 0x05f8 = 1528
> FAT16: ret: 0x000005f9, entry: 0x000005f8, offset: 0x05f8
> FAT16: entry: 0x000005f9 = 1529, offset: 0x05f9 = 1529
> FAT16: ret: 0x000005fa, entry: 0x000005f9, offset: 0x05f9
> FAT16: entry: 0x000005fa = 1530, offset: 0x05fa = 1530
> FAT16: ret: 0x000005fb, entry: 0x000005fa, offset: 0x05fa
> FAT16: entry: 0x000005fb = 1531, offset: 0x05fb = 1531
> FAT16: ret: 0x000005fc, entry: 0x000005fb, offset: 0x05fb
> FAT16: entry: 0x000005fc = 1532, offset: 0x05fc = 1532
> FAT16: ret: 0x000005fd, entry: 0x000005fc, offset: 0x05fc
> FAT16: entry: 0x000005fd = 1533, offset: 0x05fd = 1533
> FAT16: ret: 0x000005fe, entry: 0x000005fd, offset: 0x05fd
> FAT16: entry: 0x000005fe = 1534, offset: 0x05fe = 1534
> FAT16: ret: 0x000005ff, entry: 0x000005fe, offset: 0x05fe
> FAT16: entry: 0x000005ff = 1535, offset: 0x05ff = 1535
> FAT16: ret: 0x00000600, entry: 0x000005ff, offset: 0x05ff
> FAT16: entry: 0x00000600 = 1536, offset: 0x0000 = 0
> debug: evicting 0, dirty: 0
> FAT16: ret: 0x00000601, entry: 0x00000600, offset: 0x0000
> FAT16: entry: 0x00000601 = 1537, offset: 0x0001 = 1
> FAT16: ret: 0x00000602, entry: 0x00000601, offset: 0x0001
> FAT16: entry: 0x00000602 = 1538, offset: 0x0002 = 2
> FAT16: ret: 0x00000603, entry: 0x00000602, offset: 0x0002
> FAT16: entry: 0x00000603 = 1539, offset: 0x0003 = 3
> FAT16: ret: 0x00000604, entry: 0x00000603, offset: 0x0003
> FAT16: entry: 0x00000604 = 1540, offset: 0x0004 = 4
> FAT16: ret: 0x00000605, entry: 0x00000604, offset: 0x0004
> FAT16: entry: 0x00000605 = 1541, offset: 0x0005 = 5
> FAT16: ret: 0x00000606, entry: 0x00000605, offset: 0x0005
> FAT16: entry: 0x00000606 = 1542, offset: 0x0006 = 6
> FAT16: ret: 0x00000607, entry: 0x00000606, offset: 0x0006
> FAT16: entry: 0x00000607 = 1543, offset: 0x0007 = 7
> FAT16: ret: 0x00000608, entry: 0x00000607, offset: 0x0007
> FAT16: entry: 0x00000608 = 1544, offset: 0x0008 = 8
> FAT16: ret: 0x00000609, entry: 0x00000608, offset: 0x0008
> FAT16: entry: 0x00000609 = 1545, offset: 0x0009 = 9
> FAT16: ret: 0x0000060a, entry: 0x00000609, offset: 0x0009
> FAT16: entry: 0x0000060a = 1546, offset: 0x000a = 10
> FAT16: ret: 0x0000060b, entry: 0x0000060a, offset: 0x000a
> FAT16: entry: 0x0000060b = 1547, offset: 0x000b = 11
> FAT16: ret: 0x0000060c, entry: 0x0000060b, offset: 0x000b
> FAT16: entry: 0x0000060c = 1548, offset: 0x000c = 12
> FAT16: ret: 0x0000060d, entry: 0x0000060c, offset: 0x000c
> FAT16: entry: 0x0000060d = 1549, offset: 0x000d = 13
> FAT16: ret: 0x0000060e, entry: 0x0000060d, offset: 0x000d
> FAT16: entry: 0x0000060e = 1550, offset: 0x000e = 14
> FAT16: ret: 0x0000060f, entry: 0x0000060e, offset: 0x000e
> FAT16: entry: 0x0000060f = 1551, offset: 0x000f = 15
> FAT16: ret: 0x00000610, entry: 0x0000060f, offset: 0x000f
> FAT16: entry: 0x00000610 = 1552, offset: 0x0010 = 16
> FAT16: ret: 0x00000611, entry: 0x00000610, offset: 0x0010
> FAT16: entry: 0x00000611 = 1553, offset: 0x0011 = 17
> FAT16: ret: 0x00000612, entry: 0x00000611, offset: 0x0011
> FAT16: entry: 0x00000612 = 1554, offset: 0x0012 = 18
> FAT16: ret: 0x00000613, entry: 0x00000612, offset: 0x0012
> FAT16: entry: 0x00000613 = 1555, offset: 0x0013 = 19
> FAT16: ret: 0x00000614, entry: 0x00000613, offset: 0x0013
> FAT16: entry: 0x00000614 = 1556, offset: 0x0014 = 20
> FAT16: ret: 0x00000615, entry: 0x00000614, offset: 0x0014
> FAT16: entry: 0x00000615 = 1557, offset: 0x0015 = 21
> FAT16: ret: 0x00000616, entry: 0x00000615, offset: 0x0015
> FAT16: entry: 0x00000616 = 1558, offset: 0x0016 = 22
> FAT16: ret: 0x00000617, entry: 0x00000616, offset: 0x0016
> FAT16: entry: 0x00000617 = 1559, offset: 0x0017 = 23
> FAT16: ret: 0x00000618, entry: 0x00000617, offset: 0x0017
> FAT16: entry: 0x00000618 = 1560, offset: 0x0018 = 24
> FAT16: ret: 0x00000619, entry: 0x00000618, offset: 0x0018
> FAT16: entry: 0x00000619 = 1561, offset: 0x0019 = 25
> FAT16: ret: 0x0000061a, entry: 0x00000619, offset: 0x0019
> FAT16: entry: 0x0000061a = 1562, offset: 0x001a = 26
> FAT16: ret: 0x0000061b, entry: 0x0000061a, offset: 0x001a
> FAT16: entry: 0x0000061b = 1563, offset: 0x001b = 27
> FAT16: ret: 0x0000061c, entry: 0x0000061b, offset: 0x001b
> FAT16: entry: 0x0000061c = 1564, offset: 0x001c = 28
> FAT16: ret: 0x0000061d, entry: 0x0000061c, offset: 0x001c
> FAT16: entry: 0x0000061d = 1565, offset: 0x001d = 29
> FAT16: ret: 0x0000061e, entry: 0x0000061d, offset: 0x001d
> FAT16: entry: 0x0000061e = 1566, offset: 0x001e = 30
> FAT16: ret: 0x0000061f, entry: 0x0000061e, offset: 0x001e
> FAT16: entry: 0x0000061f = 1567, offset: 0x001f = 31
> FAT16: ret: 0x00000620, entry: 0x0000061f, offset: 0x001f
> FAT16: entry: 0x00000620 = 1568, offset: 0x0020 = 32
> FAT16: ret: 0x00000621, entry: 0x00000620, offset: 0x0020
> FAT16: entry: 0x00000621 = 1569, offset: 0x0021 = 33
> FAT16: ret: 0x00000622, entry: 0x00000621, offset: 0x0021
> FAT16: entry: 0x00000622 = 1570, offset: 0x0022 = 34
> FAT16: ret: 0x00000623, entry: 0x00000622, offset: 0x0022
> FAT16: entry: 0x00000623 = 1571, offset: 0x0023 = 35
> FAT16: ret: 0x00000624, entry: 0x00000623, offset: 0x0023
> FAT16: entry: 0x00000624 = 1572, offset: 0x0024 = 36
> FAT16: ret: 0x00000625, entry: 0x00000624, offset: 0x0024
> FAT16: entry: 0x00000625 = 1573, offset: 0x0025 = 37
> FAT16: ret: 0x00000626, entry: 0x00000625, offset: 0x0025
> FAT16: entry: 0x00000626 = 1574, offset: 0x0026 = 38
> FAT16: ret: 0x00000627, entry: 0x00000626, offset: 0x0026
> FAT16: entry: 0x00000627 = 1575, offset: 0x0027 = 39
> FAT16: ret: 0x00000628, entry: 0x00000627, offset: 0x0027
> FAT16: entry: 0x00000628 = 1576, offset: 0x0028 = 40
> FAT16: ret: 0x00000629, entry: 0x00000628, offset: 0x0028
> FAT16: entry: 0x00000629 = 1577, offset: 0x0029 = 41
> FAT16: ret: 0x0000062a, entry: 0x00000629, offset: 0x0029
> FAT16: entry: 0x0000062a = 1578, offset: 0x002a = 42
> FAT16: ret: 0x0000062b, entry: 0x0000062a, offset: 0x002a
> FAT16: entry: 0x0000062b = 1579, offset: 0x002b = 43
> FAT16: ret: 0x0000062c, entry: 0x0000062b, offset: 0x002b
> clustnum: 525, startsect: 2525, pos: 0
> FAT16: entry: 0x0000062c = 1580, offset: 0x002c = 44
> FAT16: ret: 0x0000ffff, entry: 0x0000062c, offset: 0x002c
> attempt to write 0x100000 bytes
> debug: evicting 1, dirty: 0
> clustnum: -6, startsect: 401
> 1048576 bytes written
> switch to partitions #0, OK
> mmc1(part 0) is current device
> switch to partitions #0, OK
> mmc0 is current device
> READING!
> FAT16, fat_sect: 1, fatlength: 200
> Rootdir begins at cluster: -6, sector: 401, offset: 32200
> Data begins at: 425
> Sector size: 512, cluster size: 4
> FAT read(sect=401), clust_size=4, DIRENTSPERBLOCK=16
> reading u-boot.img at pos 0
> Filesize: 1048576 bytes
> 1048576 bytes
> FAT16: entry: 0x0000020d = 525, offset: 0x020d = 525
> debug: evicting -1, dirty: 0
> FAT16: ret: 0x0000020e, entry: 0x0000020d, offset: 0x020d
> FAT16: entry: 0x0000020e = 526, offset: 0x020e = 526
> FAT16: ret: 0x0000020f, entry: 0x0000020e, offset: 0x020e
> FAT16: entry: 0x0000020f = 527, offset: 0x020f = 527
> FAT16: ret: 0x00000210, entry: 0x0000020f, offset: 0x020f
> FAT16: entry: 0x00000210 = 528, offset: 0x0210 = 528
> FAT16: ret: 0x00000211, entry: 0x00000210, offset: 0x0210
> FAT16: entry: 0x00000211 = 529, offset: 0x0211 = 529
> FAT16: ret: 0x00000212, entry: 0x00000211, offset: 0x0211
> FAT16: entry: 0x00000212 = 530, offset: 0x0212 = 530
> FAT16: ret: 0x00000213, entry: 0x00000212, offset: 0x0212
> FAT16: entry: 0x00000213 = 531, offset: 0x0213 = 531
> FAT16: ret: 0x00000214, entry: 0x00000213, offset: 0x0213
> FAT16: entry: 0x00000214 = 532, offset: 0x0214 = 532
> FAT16: ret: 0x00000215, entry: 0x00000214, offset: 0x0214
> FAT16: entry: 0x00000215 = 533, offset: 0x0215 = 533
> FAT16: ret: 0x00000216, entry: 0x00000215, offset: 0x0215
> FAT16: entry: 0x00000216 = 534, offset: 0x0216 = 534
> FAT16: ret: 0x00000217, entry: 0x00000216, offset: 0x0216
> FAT16: entry: 0x00000217 = 535, offset: 0x0217 = 535
> FAT16: ret: 0x00000218, entry: 0x00000217, offset: 0x0217
> FAT16: entry: 0x00000218 = 536, offset: 0x0218 = 536
> FAT16: ret: 0x00000219, entry: 0x00000218, offset: 0x0218
> FAT16: entry: 0x00000219 = 537, offset: 0x0219 = 537
> FAT16: ret: 0x0000021a, entry: 0x00000219, offset: 0x0219
> FAT16: entry: 0x0000021a = 538, offset: 0x021a = 538
> FAT16: ret: 0x0000021b, entry: 0x0000021a, offset: 0x021a
> FAT16: entry: 0x0000021b = 539, offset: 0x021b = 539
> FAT16: ret: 0x0000021c, entry: 0x0000021b, offset: 0x021b
> FAT16: entry: 0x0000021c = 540, offset: 0x021c = 540
> FAT16: ret: 0x0000021d, entry: 0x0000021c, offset: 0x021c
> FAT16: entry: 0x0000021d = 541, offset: 0x021d = 541
> FAT16: ret: 0x0000021e, entry: 0x0000021d, offset: 0x021d
> FAT16: entry: 0x0000021e = 542, offset: 0x021e = 542
> FAT16: ret: 0x0000021f, entry: 0x0000021e, offset: 0x021e
> FAT16: entry: 0x0000021f = 543, offset: 0x021f = 543
> FAT16: ret: 0x00000220, entry: 0x0000021f, offset: 0x021f
> FAT16: entry: 0x00000220 = 544, offset: 0x0220 = 544
> FAT16: ret: 0x00000221, entry: 0x00000220, offset: 0x0220
> FAT16: entry: 0x00000221 = 545, offset: 0x0221 = 545
> FAT16: ret: 0x00000222, entry: 0x00000221, offset: 0x0221
> FAT16: entry: 0x00000222 = 546, offset: 0x0222 = 546
> FAT16: ret: 0x00000223, entry: 0x00000222, offset: 0x0222
> FAT16: entry: 0x00000223 = 547, offset: 0x0223 = 547
> FAT16: ret: 0x00000224, entry: 0x00000223, offset: 0x0223
> FAT16: entry: 0x00000224 = 548, offset: 0x0224 = 548
> FAT16: ret: 0x00000225, entry: 0x00000224, offset: 0x0224
> FAT16: entry: 0x00000225 = 549, offset: 0x0225 = 549
> FAT16: ret: 0x00000226, entry: 0x00000225, offset: 0x0225
> FAT16: entry: 0x00000226 = 550, offset: 0x0226 = 550
> FAT16: ret: 0x00000227, entry: 0x00000226, offset: 0x0226
> FAT16: entry: 0x00000227 = 551, offset: 0x0227 = 551
> FAT16: ret: 0x00000228, entry: 0x00000227, offset: 0x0227
> FAT16: entry: 0x00000228 = 552, offset: 0x0228 = 552
> FAT16: ret: 0x00000229, entry: 0x00000228, offset: 0x0228
> FAT16: entry: 0x00000229 = 553, offset: 0x0229 = 553
> FAT16: ret: 0x0000022a, entry: 0x00000229, offset: 0x0229
> FAT16: entry: 0x0000022a = 554, offset: 0x022a = 554
> FAT16: ret: 0x0000022b, entry: 0x0000022a, offset: 0x022a
> FAT16: entry: 0x0000022b = 555, offset: 0x022b = 555
> FAT16: ret: 0x0000022c, entry: 0x0000022b, offset: 0x022b
> FAT16: entry: 0x0000022c = 556, offset: 0x022c = 556
> FAT16: ret: 0x0000022d, entry: 0x0000022c, offset: 0x022c
> FAT16: entry: 0x0000022d = 557, offset: 0x022d = 557
> FAT16: ret: 0x0000022e, entry: 0x0000022d, offset: 0x022d
> FAT16: entry: 0x0000022e = 558, offset: 0x022e = 558
> FAT16: ret: 0x0000022f, entry: 0x0000022e, offset: 0x022e
> FAT16: entry: 0x0000022f = 559, offset: 0x022f = 559
> FAT16: ret: 0x00000230, entry: 0x0000022f, offset: 0x022f
> FAT16: entry: 0x00000230 = 560, offset: 0x0230 = 560
> FAT16: ret: 0x00000231, entry: 0x00000230, offset: 0x0230
> FAT16: entry: 0x00000231 = 561, offset: 0x0231 = 561
> FAT16: ret: 0x00000232, entry: 0x00000231, offset: 0x0231
> FAT16: entry: 0x00000232 = 562, offset: 0x0232 = 562
> FAT16: ret: 0x00000233, entry: 0x00000232, offset: 0x0232
> FAT16: entry: 0x00000233 = 563, offset: 0x0233 = 563
> FAT16: ret: 0x00000234, entry: 0x00000233, offset: 0x0233
> FAT16: entry: 0x00000234 = 564, offset: 0x0234 = 564
> FAT16: ret: 0x00000235, entry: 0x00000234, offset: 0x0234
> FAT16: entry: 0x00000235 = 565, offset: 0x0235 = 565
> FAT16: ret: 0x00000236, entry: 0x00000235, offset: 0x0235
> FAT16: entry: 0x00000236 = 566, offset: 0x0236 = 566
> FAT16: ret: 0x00000237, entry: 0x00000236, offset: 0x0236
> FAT16: entry: 0x00000237 = 567, offset: 0x0237 = 567
> FAT16: ret: 0x00000238, entry: 0x00000237, offset: 0x0237
> FAT16: entry: 0x00000238 = 568, offset: 0x0238 = 568
> FAT16: ret: 0x00000239, entry: 0x00000238, offset: 0x0238
> FAT16: entry: 0x00000239 = 569, offset: 0x0239 = 569
> FAT16: ret: 0x0000023a, entry: 0x00000239, offset: 0x0239
> FAT16: entry: 0x0000023a = 570, offset: 0x023a = 570
> FAT16: ret: 0x0000023b, entry: 0x0000023a, offset: 0x023a
> FAT16: entry: 0x0000023b = 571, offset: 0x023b = 571
> FAT16: ret: 0x0000023c, entry: 0x0000023b, offset: 0x023b
> FAT16: entry: 0x0000023c = 572, offset: 0x023c = 572
> FAT16: ret: 0x0000023d, entry: 0x0000023c, offset: 0x023c
> FAT16: entry: 0x0000023d = 573, offset: 0x023d = 573
> FAT16: ret: 0x0000023e, entry: 0x0000023d, offset: 0x023d
> FAT16: entry: 0x0000023e = 574, offset: 0x023e = 574
> FAT16: ret: 0x0000023f, entry: 0x0000023e, offset: 0x023e
> FAT16: entry: 0x0000023f = 575, offset: 0x023f = 575
> FAT16: ret: 0x00000240, entry: 0x0000023f, offset: 0x023f
> FAT16: entry: 0x00000240 = 576, offset: 0x0240 = 576
> FAT16: ret: 0x00000241, entry: 0x00000240, offset: 0x0240
> FAT16: entry: 0x00000241 = 577, offset: 0x0241 = 577
> FAT16: ret: 0x00000242, entry: 0x00000241, offset: 0x0241
> FAT16: entry: 0x00000242 = 578, offset: 0x0242 = 578
> FAT16: ret: 0x00000243, entry: 0x00000242, offset: 0x0242
> FAT16: entry: 0x00000243 = 579, offset: 0x0243 = 579
> FAT16: ret: 0x00000244, entry: 0x00000243, offset: 0x0243
> FAT16: entry: 0x00000244 = 580, offset: 0x0244 = 580
> FAT16: ret: 0x00000245, entry: 0x00000244, offset: 0x0244
> FAT16: entry: 0x00000245 = 581, offset: 0x0245 = 581
> FAT16: ret: 0x00000246, entry: 0x00000245, offset: 0x0245
> FAT16: entry: 0x00000246 = 582, offset: 0x0246 = 582
> FAT16: ret: 0x00000247, entry: 0x00000246, offset: 0x0246
> FAT16: entry: 0x00000247 = 583, offset: 0x0247 = 583
> FAT16: ret: 0x00000248, entry: 0x00000247, offset: 0x0247
> FAT16: entry: 0x00000248 = 584, offset: 0x0248 = 584
> FAT16: ret: 0x00000249, entry: 0x00000248, offset: 0x0248
> FAT16: entry: 0x00000249 = 585, offset: 0x0249 = 585
> FAT16: ret: 0x0000024a, entry: 0x00000249, offset: 0x0249
> FAT16: entry: 0x0000024a = 586, offset: 0x024a = 586
> FAT16: ret: 0x0000024b, entry: 0x0000024a, offset: 0x024a
> FAT16: entry: 0x0000024b = 587, offset: 0x024b = 587
> FAT16: ret: 0x0000024c, entry: 0x0000024b, offset: 0x024b
> FAT16: entry: 0x0000024c = 588, offset: 0x024c = 588
> FAT16: ret: 0x0000024d, entry: 0x0000024c, offset: 0x024c
> FAT16: entry: 0x0000024d = 589, offset: 0x024d = 589
> FAT16: ret: 0x0000024e, entry: 0x0000024d, offset: 0x024d
> FAT16: entry: 0x0000024e = 590, offset: 0x024e = 590
> FAT16: ret: 0x0000024f, entry: 0x0000024e, offset: 0x024e
> FAT16: entry: 0x0000024f = 591, offset: 0x024f = 591
> FAT16: ret: 0x00000250, entry: 0x0000024f, offset: 0x024f
> FAT16: entry: 0x00000250 = 592, offset: 0x0250 = 592
> FAT16: ret: 0x00000251, entry: 0x00000250, offset: 0x0250
> FAT16: entry: 0x00000251 = 593, offset: 0x0251 = 593
> FAT16: ret: 0x00000252, entry: 0x00000251, offset: 0x0251
> FAT16: entry: 0x00000252 = 594, offset: 0x0252 = 594
> FAT16: ret: 0x00000253, entry: 0x00000252, offset: 0x0252
> FAT16: entry: 0x00000253 = 595, offset: 0x0253 = 595
> FAT16: ret: 0x00000254, entry: 0x00000253, offset: 0x0253
> FAT16: entry: 0x00000254 = 596, offset: 0x0254 = 596
> FAT16: ret: 0x00000255, entry: 0x00000254, offset: 0x0254
> FAT16: entry: 0x00000255 = 597, offset: 0x0255 = 597
> FAT16: ret: 0x00000256, entry: 0x00000255, offset: 0x0255
> FAT16: entry: 0x00000256 = 598, offset: 0x0256 = 598
> FAT16: ret: 0x00000257, entry: 0x00000256, offset: 0x0256
> FAT16: entry: 0x00000257 = 599, offset: 0x0257 = 599
> FAT16: ret: 0x00000258, entry: 0x00000257, offset: 0x0257
> FAT16: entry: 0x00000258 = 600, offset: 0x0258 = 600
> FAT16: ret: 0x00000259, entry: 0x00000258, offset: 0x0258
> FAT16: entry: 0x00000259 = 601, offset: 0x0259 = 601
> FAT16: ret: 0x0000025a, entry: 0x00000259, offset: 0x0259
> FAT16: entry: 0x0000025a = 602, offset: 0x025a = 602
> FAT16: ret: 0x0000025b, entry: 0x0000025a, offset: 0x025a
> FAT16: entry: 0x0000025b = 603, offset: 0x025b = 603
> FAT16: ret: 0x0000025c, entry: 0x0000025b, offset: 0x025b
> FAT16: entry: 0x0000025c = 604, offset: 0x025c = 604
> FAT16: ret: 0x0000025d, entry: 0x0000025c, offset: 0x025c
> FAT16: entry: 0x0000025d = 605, offset: 0x025d = 605
> FAT16: ret: 0x0000025e, entry: 0x0000025d, offset: 0x025d
> FAT16: entry: 0x0000025e = 606, offset: 0x025e = 606
> FAT16: ret: 0x0000025f, entry: 0x0000025e, offset: 0x025e
> FAT16: entry: 0x0000025f = 607, offset: 0x025f = 607
> FAT16: ret: 0x00000260, entry: 0x0000025f, offset: 0x025f
> FAT16: entry: 0x00000260 = 608, offset: 0x0260 = 608
> FAT16: ret: 0x00000261, entry: 0x00000260, offset: 0x0260
> FAT16: entry: 0x00000261 = 609, offset: 0x0261 = 609
> FAT16: ret: 0x00000262, entry: 0x00000261, offset: 0x0261
> FAT16: entry: 0x00000262 = 610, offset: 0x0262 = 610
> FAT16: ret: 0x00000263, entry: 0x00000262, offset: 0x0262
> FAT16: entry: 0x00000263 = 611, offset: 0x0263 = 611
> FAT16: ret: 0x00000264, entry: 0x00000263, offset: 0x0263
> FAT16: entry: 0x00000264 = 612, offset: 0x0264 = 612
> FAT16: ret: 0x00000265, entry: 0x00000264, offset: 0x0264
> FAT16: entry: 0x00000265 = 613, offset: 0x0265 = 613
> FAT16: ret: 0x00000266, entry: 0x00000265, offset: 0x0265
> FAT16: entry: 0x00000266 = 614, offset: 0x0266 = 614
> FAT16: ret: 0x00000267, entry: 0x00000266, offset: 0x0266
> FAT16: entry: 0x00000267 = 615, offset: 0x0267 = 615
> FAT16: ret: 0x00000268, entry: 0x00000267, offset: 0x0267
> FAT16: entry: 0x00000268 = 616, offset: 0x0268 = 616
> FAT16: ret: 0x00000269, entry: 0x00000268, offset: 0x0268
> FAT16: entry: 0x00000269 = 617, offset: 0x0269 = 617
> FAT16: ret: 0x0000026a, entry: 0x00000269, offset: 0x0269
> FAT16: entry: 0x0000026a = 618, offset: 0x026a = 618
> FAT16: ret: 0x0000026b, entry: 0x0000026a, offset: 0x026a
> FAT16: entry: 0x0000026b = 619, offset: 0x026b = 619
> FAT16: ret: 0x0000026c, entry: 0x0000026b, offset: 0x026b
> FAT16: entry: 0x0000026c = 620, offset: 0x026c = 620
> FAT16: ret: 0x0000026d, entry: 0x0000026c, offset: 0x026c
> FAT16: entry: 0x0000026d = 621, offset: 0x026d = 621
> FAT16: ret: 0x0000026e, entry: 0x0000026d, offset: 0x026d
> FAT16: entry: 0x0000026e = 622, offset: 0x026e = 622
> FAT16: ret: 0x0000026f, entry: 0x0000026e, offset: 0x026e
> FAT16: entry: 0x0000026f = 623, offset: 0x026f = 623
> FAT16: ret: 0x00000270, entry: 0x0000026f, offset: 0x026f
> FAT16: entry: 0x00000270 = 624, offset: 0x0270 = 624
> FAT16: ret: 0x00000271, entry: 0x00000270, offset: 0x0270
> FAT16: entry: 0x00000271 = 625, offset: 0x0271 = 625
> FAT16: ret: 0x00000272, entry: 0x00000271, offset: 0x0271
> FAT16: entry: 0x00000272 = 626, offset: 0x0272 = 626
> FAT16: ret: 0x00000273, entry: 0x00000272, offset: 0x0272
> FAT16: entry: 0x00000273 = 627, offset: 0x0273 = 627
> FAT16: ret: 0x00000274, entry: 0x00000273, offset: 0x0273
> FAT16: entry: 0x00000274 = 628, offset: 0x0274 = 628
> FAT16: ret: 0x00000275, entry: 0x00000274, offset: 0x0274
> FAT16: entry: 0x00000275 = 629, offset: 0x0275 = 629
> FAT16: ret: 0x00000276, entry: 0x00000275, offset: 0x0275
> FAT16: entry: 0x00000276 = 630, offset: 0x0276 = 630
> FAT16: ret: 0x00000277, entry: 0x00000276, offset: 0x0276
> FAT16: entry: 0x00000277 = 631, offset: 0x0277 = 631
> FAT16: ret: 0x00000278, entry: 0x00000277, offset: 0x0277
> FAT16: entry: 0x00000278 = 632, offset: 0x0278 = 632
> FAT16: ret: 0x00000279, entry: 0x00000278, offset: 0x0278
> FAT16: entry: 0x00000279 = 633, offset: 0x0279 = 633
> FAT16: ret: 0x0000027a, entry: 0x00000279, offset: 0x0279
> FAT16: entry: 0x0000027a = 634, offset: 0x027a = 634
> FAT16: ret: 0x0000027b, entry: 0x0000027a, offset: 0x027a
> FAT16: entry: 0x0000027b = 635, offset: 0x027b = 635
> FAT16: ret: 0x0000027c, entry: 0x0000027b, offset: 0x027b
> FAT16: entry: 0x0000027c = 636, offset: 0x027c = 636
> FAT16: ret: 0x0000027d, entry: 0x0000027c, offset: 0x027c
> FAT16: entry: 0x0000027d = 637, offset: 0x027d = 637
> FAT16: ret: 0x0000027e, entry: 0x0000027d, offset: 0x027d
> FAT16: entry: 0x0000027e = 638, offset: 0x027e = 638
> FAT16: ret: 0x0000027f, entry: 0x0000027e, offset: 0x027e
> FAT16: entry: 0x0000027f = 639, offset: 0x027f = 639
> FAT16: ret: 0x00000280, entry: 0x0000027f, offset: 0x027f
> FAT16: entry: 0x00000280 = 640, offset: 0x0280 = 640
> FAT16: ret: 0x00000281, entry: 0x00000280, offset: 0x0280
> FAT16: entry: 0x00000281 = 641, offset: 0x0281 = 641
> FAT16: ret: 0x00000282, entry: 0x00000281, offset: 0x0281
> FAT16: entry: 0x00000282 = 642, offset: 0x0282 = 642
> FAT16: ret: 0x00000283, entry: 0x00000282, offset: 0x0282
> FAT16: entry: 0x00000283 = 643, offset: 0x0283 = 643
> FAT16: ret: 0x00000284, entry: 0x00000283, offset: 0x0283
> FAT16: entry: 0x00000284 = 644, offset: 0x0284 = 644
> FAT16: ret: 0x00000285, entry: 0x00000284, offset: 0x0284
> FAT16: entry: 0x00000285 = 645, offset: 0x0285 = 645
> FAT16: ret: 0x00000286, entry: 0x00000285, offset: 0x0285
> FAT16: entry: 0x00000286 = 646, offset: 0x0286 = 646
> FAT16: ret: 0x00000287, entry: 0x00000286, offset: 0x0286
> FAT16: entry: 0x00000287 = 647, offset: 0x0287 = 647
> FAT16: ret: 0x00000288, entry: 0x00000287, offset: 0x0287
> FAT16: entry: 0x00000288 = 648, offset: 0x0288 = 648
> FAT16: ret: 0x00000289, entry: 0x00000288, offset: 0x0288
> FAT16: entry: 0x00000289 = 649, offset: 0x0289 = 649
> FAT16: ret: 0x0000028a, entry: 0x00000289, offset: 0x0289
> FAT16: entry: 0x0000028a = 650, offset: 0x028a = 650
> FAT16: ret: 0x0000028b, entry: 0x0000028a, offset: 0x028a
> FAT16: entry: 0x0000028b = 651, offset: 0x028b = 651
> FAT16: ret: 0x0000028c, entry: 0x0000028b, offset: 0x028b
> FAT16: entry: 0x0000028c = 652, offset: 0x028c = 652
> FAT16: ret: 0x0000028d, entry: 0x0000028c, offset: 0x028c
> FAT16: entry: 0x0000028d = 653, offset: 0x028d = 653
> FAT16: ret: 0x0000028e, entry: 0x0000028d, offset: 0x028d
> FAT16: entry: 0x0000028e = 654, offset: 0x028e = 654
> FAT16: ret: 0x0000028f, entry: 0x0000028e, offset: 0x028e
> FAT16: entry: 0x0000028f = 655, offset: 0x028f = 655
> FAT16: ret: 0x00000290, entry: 0x0000028f, offset: 0x028f
> FAT16: entry: 0x00000290 = 656, offset: 0x0290 = 656
> FAT16: ret: 0x00000291, entry: 0x00000290, offset: 0x0290
> FAT16: entry: 0x00000291 = 657, offset: 0x0291 = 657
> FAT16: ret: 0x00000292, entry: 0x00000291, offset: 0x0291
> FAT16: entry: 0x00000292 = 658, offset: 0x0292 = 658
> FAT16: ret: 0x00000293, entry: 0x00000292, offset: 0x0292
> FAT16: entry: 0x00000293 = 659, offset: 0x0293 = 659
> FAT16: ret: 0x00000294, entry: 0x00000293, offset: 0x0293
> FAT16: entry: 0x00000294 = 660, offset: 0x0294 = 660
> FAT16: ret: 0x00000295, entry: 0x00000294, offset: 0x0294
> FAT16: entry: 0x00000295 = 661, offset: 0x0295 = 661
> FAT16: ret: 0x00000296, entry: 0x00000295, offset: 0x0295
> FAT16: entry: 0x00000296 = 662, offset: 0x0296 = 662
> FAT16: ret: 0x00000297, entry: 0x00000296, offset: 0x0296
> FAT16: entry: 0x00000297 = 663, offset: 0x0297 = 663
> FAT16: ret: 0x00000298, entry: 0x00000297, offset: 0x0297
> FAT16: entry: 0x00000298 = 664, offset: 0x0298 = 664
> FAT16: ret: 0x00000299, entry: 0x00000298, offset: 0x0298
> FAT16: entry: 0x00000299 = 665, offset: 0x0299 = 665
> FAT16: ret: 0x0000029a, entry: 0x00000299, offset: 0x0299
> FAT16: entry: 0x0000029a = 666, offset: 0x029a = 666
> FAT16: ret: 0x0000029b, entry: 0x0000029a, offset: 0x029a
> FAT16: entry: 0x0000029b = 667, offset: 0x029b = 667
> FAT16: ret: 0x0000029c, entry: 0x0000029b, offset: 0x029b
> FAT16: entry: 0x0000029c = 668, offset: 0x029c = 668
> FAT16: ret: 0x0000029d, entry: 0x0000029c, offset: 0x029c
> FAT16: entry: 0x0000029d = 669, offset: 0x029d = 669
> FAT16: ret: 0x0000029e, entry: 0x0000029d, offset: 0x029d
> FAT16: entry: 0x0000029e = 670, offset: 0x029e = 670
> FAT16: ret: 0x0000029f, entry: 0x0000029e, offset: 0x029e
> FAT16: entry: 0x0000029f = 671, offset: 0x029f = 671
> FAT16: ret: 0x000002a0, entry: 0x0000029f, offset: 0x029f
> FAT16: entry: 0x000002a0 = 672, offset: 0x02a0 = 672
> FAT16: ret: 0x000002a1, entry: 0x000002a0, offset: 0x02a0
> FAT16: entry: 0x000002a1 = 673, offset: 0x02a1 = 673
> FAT16: ret: 0x000002a2, entry: 0x000002a1, offset: 0x02a1
> FAT16: entry: 0x000002a2 = 674, offset: 0x02a2 = 674
> FAT16: ret: 0x000002a3, entry: 0x000002a2, offset: 0x02a2
> FAT16: entry: 0x000002a3 = 675, offset: 0x02a3 = 675
> FAT16: ret: 0x000002a4, entry: 0x000002a3, offset: 0x02a3
> FAT16: entry: 0x000002a4 = 676, offset: 0x02a4 = 676
> FAT16: ret: 0x000002a5, entry: 0x000002a4, offset: 0x02a4
> FAT16: entry: 0x000002a5 = 677, offset: 0x02a5 = 677
> FAT16: ret: 0x000002a6, entry: 0x000002a5, offset: 0x02a5
> FAT16: entry: 0x000002a6 = 678, offset: 0x02a6 = 678
> FAT16: ret: 0x000002a7, entry: 0x000002a6, offset: 0x02a6
> FAT16: entry: 0x000002a7 = 679, offset: 0x02a7 = 679
> FAT16: ret: 0x000002a8, entry: 0x000002a7, offset: 0x02a7
> FAT16: entry: 0x000002a8 = 680, offset: 0x02a8 = 680
> FAT16: ret: 0x000002a9, entry: 0x000002a8, offset: 0x02a8
> FAT16: entry: 0x000002a9 = 681, offset: 0x02a9 = 681
> FAT16: ret: 0x000002aa, entry: 0x000002a9, offset: 0x02a9
> FAT16: entry: 0x000002aa = 682, offset: 0x02aa = 682
> FAT16: ret: 0x000002ab, entry: 0x000002aa, offset: 0x02aa
> FAT16: entry: 0x000002ab = 683, offset: 0x02ab = 683
> FAT16: ret: 0x000002ac, entry: 0x000002ab, offset: 0x02ab
> FAT16: entry: 0x000002ac = 684, offset: 0x02ac = 684
> FAT16: ret: 0x000002ad, entry: 0x000002ac, offset: 0x02ac
> FAT16: entry: 0x000002ad = 685, offset: 0x02ad = 685
> FAT16: ret: 0x000002ae, entry: 0x000002ad, offset: 0x02ad
> FAT16: entry: 0x000002ae = 686, offset: 0x02ae = 686
> FAT16: ret: 0x000002af, entry: 0x000002ae, offset: 0x02ae
> FAT16: entry: 0x000002af = 687, offset: 0x02af = 687
> FAT16: ret: 0x000002b0, entry: 0x000002af, offset: 0x02af
> FAT16: entry: 0x000002b0 = 688, offset: 0x02b0 = 688
> FAT16: ret: 0x000002b1, entry: 0x000002b0, offset: 0x02b0
> FAT16: entry: 0x000002b1 = 689, offset: 0x02b1 = 689
> FAT16: ret: 0x000002b2, entry: 0x000002b1, offset: 0x02b1
> FAT16: entry: 0x000002b2 = 690, offset: 0x02b2 = 690
> FAT16: ret: 0x000002b3, entry: 0x000002b2, offset: 0x02b2
> FAT16: entry: 0x000002b3 = 691, offset: 0x02b3 = 691
> FAT16: ret: 0x000002b4, entry: 0x000002b3, offset: 0x02b3
> FAT16: entry: 0x000002b4 = 692, offset: 0x02b4 = 692
> FAT16: ret: 0x000002b5, entry: 0x000002b4, offset: 0x02b4
> FAT16: entry: 0x000002b5 = 693, offset: 0x02b5 = 693
> FAT16: ret: 0x000002b6, entry: 0x000002b5, offset: 0x02b5
> FAT16: entry: 0x000002b6 = 694, offset: 0x02b6 = 694
> FAT16: ret: 0x000002b7, entry: 0x000002b6, offset: 0x02b6
> FAT16: entry: 0x000002b7 = 695, offset: 0x02b7 = 695
> FAT16: ret: 0x000002b8, entry: 0x000002b7, offset: 0x02b7
> FAT16: entry: 0x000002b8 = 696, offset: 0x02b8 = 696
> FAT16: ret: 0x000002b9, entry: 0x000002b8, offset: 0x02b8
> FAT16: entry: 0x000002b9 = 697, offset: 0x02b9 = 697
> FAT16: ret: 0x000002ba, entry: 0x000002b9, offset: 0x02b9
> FAT16: entry: 0x000002ba = 698, offset: 0x02ba = 698
> FAT16: ret: 0x000002bb, entry: 0x000002ba, offset: 0x02ba
> FAT16: entry: 0x000002bb = 699, offset: 0x02bb = 699
> FAT16: ret: 0x000002bc, entry: 0x000002bb, offset: 0x02bb
> FAT16: entry: 0x000002bc = 700, offset: 0x02bc = 700
> FAT16: ret: 0x000002bd, entry: 0x000002bc, offset: 0x02bc
> FAT16: entry: 0x000002bd = 701, offset: 0x02bd = 701
> FAT16: ret: 0x000002be, entry: 0x000002bd, offset: 0x02bd
> FAT16: entry: 0x000002be = 702, offset: 0x02be = 702
> FAT16: ret: 0x000002bf, entry: 0x000002be, offset: 0x02be
> FAT16: entry: 0x000002bf = 703, offset: 0x02bf = 703
> FAT16: ret: 0x000002c0, entry: 0x000002bf, offset: 0x02bf
> FAT16: entry: 0x000002c0 = 704, offset: 0x02c0 = 704
> FAT16: ret: 0x000002c1, entry: 0x000002c0, offset: 0x02c0
> FAT16: entry: 0x000002c1 = 705, offset: 0x02c1 = 705
> FAT16: ret: 0x000002c2, entry: 0x000002c1, offset: 0x02c1
> FAT16: entry: 0x000002c2 = 706, offset: 0x02c2 = 706
> FAT16: ret: 0x000002c3, entry: 0x000002c2, offset: 0x02c2
> FAT16: entry: 0x000002c3 = 707, offset: 0x02c3 = 707
> FAT16: ret: 0x000002c4, entry: 0x000002c3, offset: 0x02c3
> FAT16: entry: 0x000002c4 = 708, offset: 0x02c4 = 708
> FAT16: ret: 0x000002c5, entry: 0x000002c4, offset: 0x02c4
> FAT16: entry: 0x000002c5 = 709, offset: 0x02c5 = 709
> FAT16: ret: 0x000002c6, entry: 0x000002c5, offset: 0x02c5
> FAT16: entry: 0x000002c6 = 710, offset: 0x02c6 = 710
> FAT16: ret: 0x000002c7, entry: 0x000002c6, offset: 0x02c6
> FAT16: entry: 0x000002c7 = 711, offset: 0x02c7 = 711
> FAT16: ret: 0x000002c8, entry: 0x000002c7, offset: 0x02c7
> FAT16: entry: 0x000002c8 = 712, offset: 0x02c8 = 712
> FAT16: ret: 0x000002c9, entry: 0x000002c8, offset: 0x02c8
> FAT16: entry: 0x000002c9 = 713, offset: 0x02c9 = 713
> FAT16: ret: 0x000002ca, entry: 0x000002c9, offset: 0x02c9
> FAT16: entry: 0x000002ca = 714, offset: 0x02ca = 714
> FAT16: ret: 0x000002cb, entry: 0x000002ca, offset: 0x02ca
> FAT16: entry: 0x000002cb = 715, offset: 0x02cb = 715
> FAT16: ret: 0x000002cc, entry: 0x000002cb, offset: 0x02cb
> FAT16: entry: 0x000002cc = 716, offset: 0x02cc = 716
> FAT16: ret: 0x000002cd, entry: 0x000002cc, offset: 0x02cc
> FAT16: entry: 0x000002cd = 717, offset: 0x02cd = 717
> FAT16: ret: 0x000002ce, entry: 0x000002cd, offset: 0x02cd
> FAT16: entry: 0x000002ce = 718, offset: 0x02ce = 718
> FAT16: ret: 0x000002ef, entry: 0x000002ce, offset: 0x02ce
> gc - clustnum: 525, startsect: 2525
> FAT16: entry: 0x000002ce = 718, offset: 0x02ce = 718
> FAT16: ret: 0x000002ef, entry: 0x000002ce, offset: 0x02ce
> FAT16: entry: 0x000002ef = 751, offset: 0x02ef = 751
> FAT16: ret: 0x000002f0, entry: 0x000002ef, offset: 0x02ef
> FAT16: entry: 0x000002f0 = 752, offset: 0x02f0 = 752
> FAT16: ret: 0x000002f1, entry: 0x000002f0, offset: 0x02f0
> FAT16: entry: 0x000002f1 = 753, offset: 0x02f1 = 753
> FAT16: ret: 0x000002f2, entry: 0x000002f1, offset: 0x02f1
> FAT16: entry: 0x000002f2 = 754, offset: 0x02f2 = 754
> FAT16: ret: 0x000002f3, entry: 0x000002f2, offset: 0x02f2
> FAT16: entry: 0x000002f3 = 755, offset: 0x02f3 = 755
> FAT16: ret: 0x000002f4, entry: 0x000002f3, offset: 0x02f3
> FAT16: entry: 0x000002f4 = 756, offset: 0x02f4 = 756
> FAT16: ret: 0x000002f5, entry: 0x000002f4, offset: 0x02f4
> FAT16: entry: 0x000002f5 = 757, offset: 0x02f5 = 757
> FAT16: ret: 0x000002f6, entry: 0x000002f5, offset: 0x02f5
> FAT16: entry: 0x000002f6 = 758, offset: 0x02f6 = 758
> FAT16: ret: 0x000002f7, entry: 0x000002f6, offset: 0x02f6
> FAT16: entry: 0x000002f7 = 759, offset: 0x02f7 = 759
> FAT16: ret: 0x000002f8, entry: 0x000002f7, offset: 0x02f7
> FAT16: entry: 0x000002f8 = 760, offset: 0x02f8 = 760
> FAT16: ret: 0x000002f9, entry: 0x000002f8, offset: 0x02f8
> FAT16: entry: 0x000002f9 = 761, offset: 0x02f9 = 761
> FAT16: ret: 0x000002fa, entry: 0x000002f9, offset: 0x02f9
> FAT16: entry: 0x000002fa = 762, offset: 0x02fa = 762
> FAT16: ret: 0x000002fb, entry: 0x000002fa, offset: 0x02fa
> FAT16: entry: 0x000002fb = 763, offset: 0x02fb = 763
> FAT16: ret: 0x000002fc, entry: 0x000002fb, offset: 0x02fb
> FAT16: entry: 0x000002fc = 764, offset: 0x02fc = 764
> FAT16: ret: 0x000002fd, entry: 0x000002fc, offset: 0x02fc
> FAT16: entry: 0x000002fd = 765, offset: 0x02fd = 765
> FAT16: ret: 0x000002fe, entry: 0x000002fd, offset: 0x02fd
> FAT16: entry: 0x000002fe = 766, offset: 0x02fe = 766
> FAT16: ret: 0x000002ff, entry: 0x000002fe, offset: 0x02fe
> FAT16: entry: 0x000002ff = 767, offset: 0x02ff = 767
> FAT16: ret: 0x00000300, entry: 0x000002ff, offset: 0x02ff
> FAT16: entry: 0x00000300 = 768, offset: 0x0300 = 768
> FAT16: ret: 0x00000301, entry: 0x00000300, offset: 0x0300
> FAT16: entry: 0x00000301 = 769, offset: 0x0301 = 769
> FAT16: ret: 0x00000302, entry: 0x00000301, offset: 0x0301
> FAT16: entry: 0x00000302 = 770, offset: 0x0302 = 770
> FAT16: ret: 0x00000303, entry: 0x00000302, offset: 0x0302
> FAT16: entry: 0x00000303 = 771, offset: 0x0303 = 771
> FAT16: ret: 0x00000304, entry: 0x00000303, offset: 0x0303
> FAT16: entry: 0x00000304 = 772, offset: 0x0304 = 772
> FAT16: ret: 0x00000305, entry: 0x00000304, offset: 0x0304
> FAT16: entry: 0x00000305 = 773, offset: 0x0305 = 773
> FAT16: ret: 0x00000306, entry: 0x00000305, offset: 0x0305
> FAT16: entry: 0x00000306 = 774, offset: 0x0306 = 774
> FAT16: ret: 0x00000307, entry: 0x00000306, offset: 0x0306
> FAT16: entry: 0x00000307 = 775, offset: 0x0307 = 775
> FAT16: ret: 0x00000308, entry: 0x00000307, offset: 0x0307
> FAT16: entry: 0x00000308 = 776, offset: 0x0308 = 776
> FAT16: ret: 0x00000309, entry: 0x00000308, offset: 0x0308
> FAT16: entry: 0x00000309 = 777, offset: 0x0309 = 777
> FAT16: ret: 0x0000030a, entry: 0x00000309, offset: 0x0309
> FAT16: entry: 0x0000030a = 778, offset: 0x030a = 778
> FAT16: ret: 0x0000030b, entry: 0x0000030a, offset: 0x030a
> FAT16: entry: 0x0000030b = 779, offset: 0x030b = 779
> FAT16: ret: 0x0000030c, entry: 0x0000030b, offset: 0x030b
> FAT16: entry: 0x0000030c = 780, offset: 0x030c = 780
> FAT16: ret: 0x0000030d, entry: 0x0000030c, offset: 0x030c
> FAT16: entry: 0x0000030d = 781, offset: 0x030d = 781
> FAT16: ret: 0x0000030e, entry: 0x0000030d, offset: 0x030d
> FAT16: entry: 0x0000030e = 782, offset: 0x030e = 782
> FAT16: ret: 0x0000030f, entry: 0x0000030e, offset: 0x030e
> FAT16: entry: 0x0000030f = 783, offset: 0x030f = 783
> FAT16: ret: 0x00000310, entry: 0x0000030f, offset: 0x030f
> FAT16: entry: 0x00000310 = 784, offset: 0x0310 = 784
> FAT16: ret: 0x00000311, entry: 0x00000310, offset: 0x0310
> FAT16: entry: 0x00000311 = 785, offset: 0x0311 = 785
> FAT16: ret: 0x00000312, entry: 0x00000311, offset: 0x0311
> FAT16: entry: 0x00000312 = 786, offset: 0x0312 = 786
> FAT16: ret: 0x00000313, entry: 0x00000312, offset: 0x0312
> FAT16: entry: 0x00000313 = 787, offset: 0x0313 = 787
> FAT16: ret: 0x00000314, entry: 0x00000313, offset: 0x0313
> FAT16: entry: 0x00000314 = 788, offset: 0x0314 = 788
> FAT16: ret: 0x00000315, entry: 0x00000314, offset: 0x0314
> FAT16: entry: 0x00000315 = 789, offset: 0x0315 = 789
> FAT16: ret: 0x00000316, entry: 0x00000315, offset: 0x0315
> FAT16: entry: 0x00000316 = 790, offset: 0x0316 = 790
> FAT16: ret: 0x00000317, entry: 0x00000316, offset: 0x0316
> FAT16: entry: 0x00000317 = 791, offset: 0x0317 = 791
> FAT16: ret: 0x00000318, entry: 0x00000317, offset: 0x0317
> FAT16: entry: 0x00000318 = 792, offset: 0x0318 = 792
> FAT16: ret: 0x00000319, entry: 0x00000318, offset: 0x0318
> FAT16: entry: 0x00000319 = 793, offset: 0x0319 = 793
> FAT16: ret: 0x0000031a, entry: 0x00000319, offset: 0x0319
> FAT16: entry: 0x0000031a = 794, offset: 0x031a = 794
> FAT16: ret: 0x0000031b, entry: 0x0000031a, offset: 0x031a
> FAT16: entry: 0x0000031b = 795, offset: 0x031b = 795
> FAT16: ret: 0x0000031c, entry: 0x0000031b, offset: 0x031b
> FAT16: entry: 0x0000031c = 796, offset: 0x031c = 796
> FAT16: ret: 0x0000031d, entry: 0x0000031c, offset: 0x031c
> FAT16: entry: 0x0000031d = 797, offset: 0x031d = 797
> FAT16: ret: 0x0000031e, entry: 0x0000031d, offset: 0x031d
> FAT16: entry: 0x0000031e = 798, offset: 0x031e = 798
> FAT16: ret: 0x0000031f, entry: 0x0000031e, offset: 0x031e
> FAT16: entry: 0x0000031f = 799, offset: 0x031f = 799
> FAT16: ret: 0x00000320, entry: 0x0000031f, offset: 0x031f
> FAT16: entry: 0x00000320 = 800, offset: 0x0320 = 800
> FAT16: ret: 0x00000321, entry: 0x00000320, offset: 0x0320
> FAT16: entry: 0x00000321 = 801, offset: 0x0321 = 801
> FAT16: ret: 0x00000322, entry: 0x00000321, offset: 0x0321
> FAT16: entry: 0x00000322 = 802, offset: 0x0322 = 802
> FAT16: ret: 0x00000323, entry: 0x00000322, offset: 0x0322
> FAT16: entry: 0x00000323 = 803, offset: 0x0323 = 803
> FAT16: ret: 0x00000324, entry: 0x00000323, offset: 0x0323
> FAT16: entry: 0x00000324 = 804, offset: 0x0324 = 804
> FAT16: ret: 0x00000325, entry: 0x00000324, offset: 0x0324
> FAT16: entry: 0x00000325 = 805, offset: 0x0325 = 805
> FAT16: ret: 0x00000326, entry: 0x00000325, offset: 0x0325
> FAT16: entry: 0x00000326 = 806, offset: 0x0326 = 806
> FAT16: ret: 0x00000327, entry: 0x00000326, offset: 0x0326
> FAT16: entry: 0x00000327 = 807, offset: 0x0327 = 807
> FAT16: ret: 0x00000328, entry: 0x00000327, offset: 0x0327
> FAT16: entry: 0x00000328 = 808, offset: 0x0328 = 808
> FAT16: ret: 0x00000329, entry: 0x00000328, offset: 0x0328
> FAT16: entry: 0x00000329 = 809, offset: 0x0329 = 809
> FAT16: ret: 0x0000032a, entry: 0x00000329, offset: 0x0329
> FAT16: entry: 0x0000032a = 810, offset: 0x032a = 810
> FAT16: ret: 0x0000032b, entry: 0x0000032a, offset: 0x032a
> FAT16: entry: 0x0000032b = 811, offset: 0x032b = 811
> FAT16: ret: 0x0000032c, entry: 0x0000032b, offset: 0x032b
> FAT16: entry: 0x0000032c = 812, offset: 0x032c = 812
> FAT16: ret: 0x0000032d, entry: 0x0000032c, offset: 0x032c
> FAT16: entry: 0x0000032d = 813, offset: 0x032d = 813
> FAT16: ret: 0x0000032e, entry: 0x0000032d, offset: 0x032d
> FAT16: entry: 0x0000032e = 814, offset: 0x032e = 814
> FAT16: ret: 0x0000032f, entry: 0x0000032e, offset: 0x032e
> FAT16: entry: 0x0000032f = 815, offset: 0x032f = 815
> FAT16: ret: 0x00000330, entry: 0x0000032f, offset: 0x032f
> FAT16: entry: 0x00000330 = 816, offset: 0x0330 = 816
> FAT16: ret: 0x00000331, entry: 0x00000330, offset: 0x0330
> FAT16: entry: 0x00000331 = 817, offset: 0x0331 = 817
> FAT16: ret: 0x00000332, entry: 0x00000331, offset: 0x0331
> FAT16: entry: 0x00000332 = 818, offset: 0x0332 = 818
> FAT16: ret: 0x00000333, entry: 0x00000332, offset: 0x0332
> FAT16: entry: 0x00000333 = 819, offset: 0x0333 = 819
> FAT16: ret: 0x00000334, entry: 0x00000333, offset: 0x0333
> FAT16: entry: 0x00000334 = 820, offset: 0x0334 = 820
> FAT16: ret: 0x00000335, entry: 0x00000334, offset: 0x0334
> FAT16: entry: 0x00000335 = 821, offset: 0x0335 = 821
> FAT16: ret: 0x00000336, entry: 0x00000335, offset: 0x0335
> FAT16: entry: 0x00000336 = 822, offset: 0x0336 = 822
> FAT16: ret: 0x00000337, entry: 0x00000336, offset: 0x0336
> FAT16: entry: 0x00000337 = 823, offset: 0x0337 = 823
> FAT16: ret: 0x00000338, entry: 0x00000337, offset: 0x0337
> FAT16: entry: 0x00000338 = 824, offset: 0x0338 = 824
> FAT16: ret: 0x00000339, entry: 0x00000338, offset: 0x0338
> FAT16: entry: 0x00000339 = 825, offset: 0x0339 = 825
> FAT16: ret: 0x0000033a, entry: 0x00000339, offset: 0x0339
> FAT16: entry: 0x0000033a = 826, offset: 0x033a = 826
> FAT16: ret: 0x0000033b, entry: 0x0000033a, offset: 0x033a
> FAT16: entry: 0x0000033b = 827, offset: 0x033b = 827
> FAT16: ret: 0x0000033c, entry: 0x0000033b, offset: 0x033b
> FAT16: entry: 0x0000033c = 828, offset: 0x033c = 828
> FAT16: ret: 0x0000033d, entry: 0x0000033c, offset: 0x033c
> FAT16: entry: 0x0000033d = 829, offset: 0x033d = 829
> FAT16: ret: 0x0000033e, entry: 0x0000033d, offset: 0x033d
> FAT16: entry: 0x0000033e = 830, offset: 0x033e = 830
> FAT16: ret: 0x0000033f, entry: 0x0000033e, offset: 0x033e
> FAT16: entry: 0x0000033f = 831, offset: 0x033f = 831
> FAT16: ret: 0x00000340, entry: 0x0000033f, offset: 0x033f
> FAT16: entry: 0x00000340 = 832, offset: 0x0340 = 832
> FAT16: ret: 0x00000341, entry: 0x00000340, offset: 0x0340
> FAT16: entry: 0x00000341 = 833, offset: 0x0341 = 833
> FAT16: ret: 0x00000342, entry: 0x00000341, offset: 0x0341
> FAT16: entry: 0x00000342 = 834, offset: 0x0342 = 834
> FAT16: ret: 0x00000343, entry: 0x00000342, offset: 0x0342
> FAT16: entry: 0x00000343 = 835, offset: 0x0343 = 835
> FAT16: ret: 0x00000344, entry: 0x00000343, offset: 0x0343
> FAT16: entry: 0x00000344 = 836, offset: 0x0344 = 836
> FAT16: ret: 0x00000345, entry: 0x00000344, offset: 0x0344
> FAT16: entry: 0x00000345 = 837, offset: 0x0345 = 837
> FAT16: ret: 0x00000346, entry: 0x00000345, offset: 0x0345
> FAT16: entry: 0x00000346 = 838, offset: 0x0346 = 838
> FAT16: ret: 0x00000347, entry: 0x00000346, offset: 0x0346
> FAT16: entry: 0x00000347 = 839, offset: 0x0347 = 839
> FAT16: ret: 0x00000348, entry: 0x00000347, offset: 0x0347
> FAT16: entry: 0x00000348 = 840, offset: 0x0348 = 840
> FAT16: ret: 0x00000349, entry: 0x00000348, offset: 0x0348
> FAT16: entry: 0x00000349 = 841, offset: 0x0349 = 841
> FAT16: ret: 0x0000034a, entry: 0x00000349, offset: 0x0349
> FAT16: entry: 0x0000034a = 842, offset: 0x034a = 842
> FAT16: ret: 0x0000034b, entry: 0x0000034a, offset: 0x034a
> FAT16: entry: 0x0000034b = 843, offset: 0x034b = 843
> FAT16: ret: 0x0000034c, entry: 0x0000034b, offset: 0x034b
> FAT16: entry: 0x0000034c = 844, offset: 0x034c = 844
> FAT16: ret: 0x0000034d, entry: 0x0000034c, offset: 0x034c
> FAT16: entry: 0x0000034d = 845, offset: 0x034d = 845
> FAT16: ret: 0x0000034e, entry: 0x0000034d, offset: 0x034d
> FAT16: entry: 0x0000034e = 846, offset: 0x034e = 846
> FAT16: ret: 0x0000034f, entry: 0x0000034e, offset: 0x034e
> FAT16: entry: 0x0000034f = 847, offset: 0x034f = 847
> FAT16: ret: 0x00000350, entry: 0x0000034f, offset: 0x034f
> FAT16: entry: 0x00000350 = 848, offset: 0x0350 = 848
> FAT16: ret: 0x00000351, entry: 0x00000350, offset: 0x0350
> FAT16: entry: 0x00000351 = 849, offset: 0x0351 = 849
> FAT16: ret: 0x00000352, entry: 0x00000351, offset: 0x0351
> FAT16: entry: 0x00000352 = 850, offset: 0x0352 = 850
> FAT16: ret: 0x00000353, entry: 0x00000352, offset: 0x0352
> FAT16: entry: 0x00000353 = 851, offset: 0x0353 = 851
> FAT16: ret: 0x00000354, entry: 0x00000353, offset: 0x0353
> FAT16: entry: 0x00000354 = 852, offset: 0x0354 = 852
> FAT16: ret: 0x00000355, entry: 0x00000354, offset: 0x0354
> FAT16: entry: 0x00000355 = 853, offset: 0x0355 = 853
> FAT16: ret: 0x00000356, entry: 0x00000355, offset: 0x0355
> FAT16: entry: 0x00000356 = 854, offset: 0x0356 = 854
> FAT16: ret: 0x00000357, entry: 0x00000356, offset: 0x0356
> FAT16: entry: 0x00000357 = 855, offset: 0x0357 = 855
> FAT16: ret: 0x00000358, entry: 0x00000357, offset: 0x0357
> FAT16: entry: 0x00000358 = 856, offset: 0x0358 = 856
> FAT16: ret: 0x00000359, entry: 0x00000358, offset: 0x0358
> FAT16: entry: 0x00000359 = 857, offset: 0x0359 = 857
> FAT16: ret: 0x0000035a, entry: 0x00000359, offset: 0x0359
> FAT16: entry: 0x0000035a = 858, offset: 0x035a = 858
> FAT16: ret: 0x0000035b, entry: 0x0000035a, offset: 0x035a
> FAT16: entry: 0x0000035b = 859, offset: 0x035b = 859
> FAT16: ret: 0x0000035c, entry: 0x0000035b, offset: 0x035b
> FAT16: entry: 0x0000035c = 860, offset: 0x035c = 860
> FAT16: ret: 0x0000035d, entry: 0x0000035c, offset: 0x035c
> FAT16: entry: 0x0000035d = 861, offset: 0x035d = 861
> FAT16: ret: 0x0000035e, entry: 0x0000035d, offset: 0x035d
> FAT16: entry: 0x0000035e = 862, offset: 0x035e = 862
> FAT16: ret: 0x0000035f, entry: 0x0000035e, offset: 0x035e
> FAT16: entry: 0x0000035f = 863, offset: 0x035f = 863
> FAT16: ret: 0x00000360, entry: 0x0000035f, offset: 0x035f
> FAT16: entry: 0x00000360 = 864, offset: 0x0360 = 864
> FAT16: ret: 0x00000361, entry: 0x00000360, offset: 0x0360
> FAT16: entry: 0x00000361 = 865, offset: 0x0361 = 865
> FAT16: ret: 0x00000362, entry: 0x00000361, offset: 0x0361
> FAT16: entry: 0x00000362 = 866, offset: 0x0362 = 866
> FAT16: ret: 0x00000363, entry: 0x00000362, offset: 0x0362
> FAT16: entry: 0x00000363 = 867, offset: 0x0363 = 867
> FAT16: ret: 0x00000364, entry: 0x00000363, offset: 0x0363
> FAT16: entry: 0x00000364 = 868, offset: 0x0364 = 868
> FAT16: ret: 0x00000365, entry: 0x00000364, offset: 0x0364
> FAT16: entry: 0x00000365 = 869, offset: 0x0365 = 869
> FAT16: ret: 0x00000366, entry: 0x00000365, offset: 0x0365
> FAT16: entry: 0x00000366 = 870, offset: 0x0366 = 870
> FAT16: ret: 0x00000367, entry: 0x00000366, offset: 0x0366
> FAT16: entry: 0x00000367 = 871, offset: 0x0367 = 871
> FAT16: ret: 0x00000368, entry: 0x00000367, offset: 0x0367
> FAT16: entry: 0x00000368 = 872, offset: 0x0368 = 872
> FAT16: ret: 0x00000369, entry: 0x00000368, offset: 0x0368
> FAT16: entry: 0x00000369 = 873, offset: 0x0369 = 873
> FAT16: ret: 0x0000036a, entry: 0x00000369, offset: 0x0369
> FAT16: entry: 0x0000036a = 874, offset: 0x036a = 874
> FAT16: ret: 0x0000036b, entry: 0x0000036a, offset: 0x036a
> FAT16: entry: 0x0000036b = 875, offset: 0x036b = 875
> FAT16: ret: 0x0000036c, entry: 0x0000036b, offset: 0x036b
> FAT16: entry: 0x0000036c = 876, offset: 0x036c = 876
> FAT16: ret: 0x0000036d, entry: 0x0000036c, offset: 0x036c
> FAT16: entry: 0x0000036d = 877, offset: 0x036d = 877
> FAT16: ret: 0x0000036e, entry: 0x0000036d, offset: 0x036d
> FAT16: entry: 0x0000036e = 878, offset: 0x036e = 878
> FAT16: ret: 0x0000036f, entry: 0x0000036e, offset: 0x036e
> FAT16: entry: 0x0000036f = 879, offset: 0x036f = 879
> FAT16: ret: 0x00000370, entry: 0x0000036f, offset: 0x036f
> FAT16: entry: 0x00000370 = 880, offset: 0x0370 = 880
> FAT16: ret: 0x00000371, entry: 0x00000370, offset: 0x0370
> FAT16: entry: 0x00000371 = 881, offset: 0x0371 = 881
> FAT16: ret: 0x00000372, entry: 0x00000371, offset: 0x0371
> FAT16: entry: 0x00000372 = 882, offset: 0x0372 = 882
> FAT16: ret: 0x00000373, entry: 0x00000372, offset: 0x0372
> FAT16: entry: 0x00000373 = 883, offset: 0x0373 = 883
> FAT16: ret: 0x00000374, entry: 0x00000373, offset: 0x0373
> FAT16: entry: 0x00000374 = 884, offset: 0x0374 = 884
> FAT16: ret: 0x00000375, entry: 0x00000374, offset: 0x0374
> FAT16: entry: 0x00000375 = 885, offset: 0x0375 = 885
> FAT16: ret: 0x00000376, entry: 0x00000375, offset: 0x0375
> FAT16: entry: 0x00000376 = 886, offset: 0x0376 = 886
> FAT16: ret: 0x00000377, entry: 0x00000376, offset: 0x0376
> FAT16: entry: 0x00000377 = 887, offset: 0x0377 = 887
> FAT16: ret: 0x00000378, entry: 0x00000377, offset: 0x0377
> FAT16: entry: 0x00000378 = 888, offset: 0x0378 = 888
> FAT16: ret: 0x00000379, entry: 0x00000378, offset: 0x0378
> FAT16: entry: 0x00000379 = 889, offset: 0x0379 = 889
> FAT16: ret: 0x0000037a, entry: 0x00000379, offset: 0x0379
> FAT16: entry: 0x0000037a = 890, offset: 0x037a = 890
> FAT16: ret: 0x0000037b, entry: 0x0000037a, offset: 0x037a
> FAT16: entry: 0x0000037b = 891, offset: 0x037b = 891
> FAT16: ret: 0x0000037c, entry: 0x0000037b, offset: 0x037b
> FAT16: entry: 0x0000037c = 892, offset: 0x037c = 892
> FAT16: ret: 0x0000037d, entry: 0x0000037c, offset: 0x037c
> FAT16: entry: 0x0000037d = 893, offset: 0x037d = 893
> FAT16: ret: 0x0000037e, entry: 0x0000037d, offset: 0x037d
> FAT16: entry: 0x0000037e = 894, offset: 0x037e = 894
> FAT16: ret: 0x0000037f, entry: 0x0000037e, offset: 0x037e
> FAT16: entry: 0x0000037f = 895, offset: 0x037f = 895
> FAT16: ret: 0x00000380, entry: 0x0000037f, offset: 0x037f
> FAT16: entry: 0x00000380 = 896, offset: 0x0380 = 896
> FAT16: ret: 0x00000381, entry: 0x00000380, offset: 0x0380
> FAT16: entry: 0x00000381 = 897, offset: 0x0381 = 897
> FAT16: ret: 0x00000382, entry: 0x00000381, offset: 0x0381
> FAT16: entry: 0x00000382 = 898, offset: 0x0382 = 898
> FAT16: ret: 0x00000383, entry: 0x00000382, offset: 0x0382
> FAT16: entry: 0x00000383 = 899, offset: 0x0383 = 899
> FAT16: ret: 0x00000384, entry: 0x00000383, offset: 0x0383
> FAT16: entry: 0x00000384 = 900, offset: 0x0384 = 900
> FAT16: ret: 0x00000385, entry: 0x00000384, offset: 0x0384
> FAT16: entry: 0x00000385 = 901, offset: 0x0385 = 901
> FAT16: ret: 0x00000386, entry: 0x00000385, offset: 0x0385
> FAT16: entry: 0x00000386 = 902, offset: 0x0386 = 902
> FAT16: ret: 0x00000387, entry: 0x00000386, offset: 0x0386
> FAT16: entry: 0x00000387 = 903, offset: 0x0387 = 903
> FAT16: ret: 0x00000388, entry: 0x00000387, offset: 0x0387
> FAT16: entry: 0x00000388 = 904, offset: 0x0388 = 904
> FAT16: ret: 0x00000389, entry: 0x00000388, offset: 0x0388
> FAT16: entry: 0x00000389 = 905, offset: 0x0389 = 905
> FAT16: ret: 0x0000038a, entry: 0x00000389, offset: 0x0389
> FAT16: entry: 0x0000038a = 906, offset: 0x038a = 906
> FAT16: ret: 0x0000038b, entry: 0x0000038a, offset: 0x038a
> FAT16: entry: 0x0000038b = 907, offset: 0x038b = 907
> FAT16: ret: 0x0000038c, entry: 0x0000038b, offset: 0x038b
> FAT16: entry: 0x0000038c = 908, offset: 0x038c = 908
> FAT16: ret: 0x0000038d, entry: 0x0000038c, offset: 0x038c
> FAT16: entry: 0x0000038d = 909, offset: 0x038d = 909
> FAT16: ret: 0x0000038e, entry: 0x0000038d, offset: 0x038d
> FAT16: entry: 0x0000038e = 910, offset: 0x038e = 910
> FAT16: ret: 0x0000038f, entry: 0x0000038e, offset: 0x038e
> FAT16: entry: 0x0000038f = 911, offset: 0x038f = 911
> FAT16: ret: 0x00000390, entry: 0x0000038f, offset: 0x038f
> FAT16: entry: 0x00000390 = 912, offset: 0x0390 = 912
> FAT16: ret: 0x00000391, entry: 0x00000390, offset: 0x0390
> FAT16: entry: 0x00000391 = 913, offset: 0x0391 = 913
> FAT16: ret: 0x00000392, entry: 0x00000391, offset: 0x0391
> FAT16: entry: 0x00000392 = 914, offset: 0x0392 = 914
> FAT16: ret: 0x00000393, entry: 0x00000392, offset: 0x0392
> FAT16: entry: 0x00000393 = 915, offset: 0x0393 = 915
> FAT16: ret: 0x00000394, entry: 0x00000393, offset: 0x0393
> FAT16: entry: 0x00000394 = 916, offset: 0x0394 = 916
> FAT16: ret: 0x00000395, entry: 0x00000394, offset: 0x0394
> FAT16: entry: 0x00000395 = 917, offset: 0x0395 = 917
> FAT16: ret: 0x00000396, entry: 0x00000395, offset: 0x0395
> FAT16: entry: 0x00000396 = 918, offset: 0x0396 = 918
> FAT16: ret: 0x00000397, entry: 0x00000396, offset: 0x0396
> FAT16: entry: 0x00000397 = 919, offset: 0x0397 = 919
> FAT16: ret: 0x00000398, entry: 0x00000397, offset: 0x0397
> FAT16: entry: 0x00000398 = 920, offset: 0x0398 = 920
> FAT16: ret: 0x00000399, entry: 0x00000398, offset: 0x0398
> FAT16: entry: 0x00000399 = 921, offset: 0x0399 = 921
> FAT16: ret: 0x0000039a, entry: 0x00000399, offset: 0x0399
> FAT16: entry: 0x0000039a = 922, offset: 0x039a = 922
> FAT16: ret: 0x0000039b, entry: 0x0000039a, offset: 0x039a
> FAT16: entry: 0x0000039b = 923, offset: 0x039b = 923
> FAT16: ret: 0x0000039c, entry: 0x0000039b, offset: 0x039b
> FAT16: entry: 0x0000039c = 924, offset: 0x039c = 924
> FAT16: ret: 0x0000039d, entry: 0x0000039c, offset: 0x039c
> FAT16: entry: 0x0000039d = 925, offset: 0x039d = 925
> FAT16: ret: 0x0000039e, entry: 0x0000039d, offset: 0x039d
> FAT16: entry: 0x0000039e = 926, offset: 0x039e = 926
> FAT16: ret: 0x0000039f, entry: 0x0000039e, offset: 0x039e
> FAT16: entry: 0x0000039f = 927, offset: 0x039f = 927
> FAT16: ret: 0x000003a0, entry: 0x0000039f, offset: 0x039f
> FAT16: entry: 0x000003a0 = 928, offset: 0x03a0 = 928
> FAT16: ret: 0x000003a1, entry: 0x000003a0, offset: 0x03a0
> FAT16: entry: 0x000003a1 = 929, offset: 0x03a1 = 929
> FAT16: ret: 0x000003a2, entry: 0x000003a1, offset: 0x03a1
> FAT16: entry: 0x000003a2 = 930, offset: 0x03a2 = 930
> FAT16: ret: 0x000003a3, entry: 0x000003a2, offset: 0x03a2
> FAT16: entry: 0x000003a3 = 931, offset: 0x03a3 = 931
> FAT16: ret: 0x000003a4, entry: 0x000003a3, offset: 0x03a3
> FAT16: entry: 0x000003a4 = 932, offset: 0x03a4 = 932
> FAT16: ret: 0x000003a5, entry: 0x000003a4, offset: 0x03a4
> FAT16: entry: 0x000003a5 = 933, offset: 0x03a5 = 933
> FAT16: ret: 0x000003a6, entry: 0x000003a5, offset: 0x03a5
> FAT16: entry: 0x000003a6 = 934, offset: 0x03a6 = 934
> FAT16: ret: 0x000003a7, entry: 0x000003a6, offset: 0x03a6
> FAT16: entry: 0x000003a7 = 935, offset: 0x03a7 = 935
> FAT16: ret: 0x000003a8, entry: 0x000003a7, offset: 0x03a7
> FAT16: entry: 0x000003a8 = 936, offset: 0x03a8 = 936
> FAT16: ret: 0x000003a9, entry: 0x000003a8, offset: 0x03a8
> FAT16: entry: 0x000003a9 = 937, offset: 0x03a9 = 937
> FAT16: ret: 0x000003aa, entry: 0x000003a9, offset: 0x03a9
> FAT16: entry: 0x000003aa = 938, offset: 0x03aa = 938
> FAT16: ret: 0x000003ab, entry: 0x000003aa, offset: 0x03aa
> FAT16: entry: 0x000003ab = 939, offset: 0x03ab = 939
> FAT16: ret: 0x000003ac, entry: 0x000003ab, offset: 0x03ab
> FAT16: entry: 0x000003ac = 940, offset: 0x03ac = 940
> FAT16: ret: 0x000003ad, entry: 0x000003ac, offset: 0x03ac
> FAT16: entry: 0x000003ad = 941, offset: 0x03ad = 941
> FAT16: ret: 0x000003ae, entry: 0x000003ad, offset: 0x03ad
> FAT16: entry: 0x000003ae = 942, offset: 0x03ae = 942
> FAT16: ret: 0x000003af, entry: 0x000003ae, offset: 0x03ae
> FAT16: entry: 0x000003af = 943, offset: 0x03af = 943
> FAT16: ret: 0x000003b0, entry: 0x000003af, offset: 0x03af
> FAT16: entry: 0x000003b0 = 944, offset: 0x03b0 = 944
> FAT16: ret: 0x000003b1, entry: 0x000003b0, offset: 0x03b0
> FAT16: entry: 0x000003b1 = 945, offset: 0x03b1 = 945
> FAT16: ret: 0x000003b2, entry: 0x000003b1, offset: 0x03b1
> FAT16: entry: 0x000003b2 = 946, offset: 0x03b2 = 946
> FAT16: ret: 0x000003b3, entry: 0x000003b2, offset: 0x03b2
> FAT16: entry: 0x000003b3 = 947, offset: 0x03b3 = 947
> FAT16: ret: 0x000003b4, entry: 0x000003b3, offset: 0x03b3
> FAT16: entry: 0x000003b4 = 948, offset: 0x03b4 = 948
> FAT16: ret: 0x000003b5, entry: 0x000003b4, offset: 0x03b4
> FAT16: entry: 0x000003b5 = 949, offset: 0x03b5 = 949
> FAT16: ret: 0x000003b6, entry: 0x000003b5, offset: 0x03b5
> FAT16: entry: 0x000003b6 = 950, offset: 0x03b6 = 950
> FAT16: ret: 0x000003b7, entry: 0x000003b6, offset: 0x03b6
> FAT16: entry: 0x000003b7 = 951, offset: 0x03b7 = 951
> FAT16: ret: 0x000003b8, entry: 0x000003b7, offset: 0x03b7
> FAT16: entry: 0x000003b8 = 952, offset: 0x03b8 = 952
> FAT16: ret: 0x000003b9, entry: 0x000003b8, offset: 0x03b8
> FAT16: entry: 0x000003b9 = 953, offset: 0x03b9 = 953
> FAT16: ret: 0x000003ba, entry: 0x000003b9, offset: 0x03b9
> FAT16: entry: 0x000003ba = 954, offset: 0x03ba = 954
> FAT16: ret: 0x000003bb, entry: 0x000003ba, offset: 0x03ba
> FAT16: entry: 0x000003bb = 955, offset: 0x03bb = 955
> FAT16: ret: 0x000003bc, entry: 0x000003bb, offset: 0x03bb
> FAT16: entry: 0x000003bc = 956, offset: 0x03bc = 956
> FAT16: ret: 0x000003bd, entry: 0x000003bc, offset: 0x03bc
> FAT16: entry: 0x000003bd = 957, offset: 0x03bd = 957
> FAT16: ret: 0x000003be, entry: 0x000003bd, offset: 0x03bd
> FAT16: entry: 0x000003be = 958, offset: 0x03be = 958
> FAT16: ret: 0x000003bf, entry: 0x000003be, offset: 0x03be
> FAT16: entry: 0x000003bf = 959, offset: 0x03bf = 959
> FAT16: ret: 0x000003c0, entry: 0x000003bf, offset: 0x03bf
> FAT16: entry: 0x000003c0 = 960, offset: 0x03c0 = 960
> FAT16: ret: 0x000003c1, entry: 0x000003c0, offset: 0x03c0
> FAT16: entry: 0x000003c1 = 961, offset: 0x03c1 = 961
> FAT16: ret: 0x000003c2, entry: 0x000003c1, offset: 0x03c1
> FAT16: entry: 0x000003c2 = 962, offset: 0x03c2 = 962
> FAT16: ret: 0x000003c3, entry: 0x000003c2, offset: 0x03c2
> FAT16: entry: 0x000003c3 = 963, offset: 0x03c3 = 963
> FAT16: ret: 0x000003c4, entry: 0x000003c3, offset: 0x03c3
> FAT16: entry: 0x000003c4 = 964, offset: 0x03c4 = 964
> FAT16: ret: 0x000003c5, entry: 0x000003c4, offset: 0x03c4
> FAT16: entry: 0x000003c5 = 965, offset: 0x03c5 = 965
> FAT16: ret: 0x000003c6, entry: 0x000003c5, offset: 0x03c5
> FAT16: entry: 0x000003c6 = 966, offset: 0x03c6 = 966
> FAT16: ret: 0x000003c7, entry: 0x000003c6, offset: 0x03c6
> FAT16: entry: 0x000003c7 = 967, offset: 0x03c7 = 967
> FAT16: ret: 0x000003c8, entry: 0x000003c7, offset: 0x03c7
> FAT16: entry: 0x000003c8 = 968, offset: 0x03c8 = 968
> FAT16: ret: 0x000003c9, entry: 0x000003c8, offset: 0x03c8
> FAT16: entry: 0x000003c9 = 969, offset: 0x03c9 = 969
> FAT16: ret: 0x000003ca, entry: 0x000003c9, offset: 0x03c9
> FAT16: entry: 0x000003ca = 970, offset: 0x03ca = 970
> FAT16: ret: 0x000003cb, entry: 0x000003ca, offset: 0x03ca
> FAT16: entry: 0x000003cb = 971, offset: 0x03cb = 971
> FAT16: ret: 0x000003cc, entry: 0x000003cb, offset: 0x03cb
> FAT16: entry: 0x000003cc = 972, offset: 0x03cc = 972
> FAT16: ret: 0x000003cd, entry: 0x000003cc, offset: 0x03cc
> FAT16: entry: 0x000003cd = 973, offset: 0x03cd = 973
> FAT16: ret: 0x000003ce, entry: 0x000003cd, offset: 0x03cd
> FAT16: entry: 0x000003ce = 974, offset: 0x03ce = 974
> FAT16: ret: 0x000003cf, entry: 0x000003ce, offset: 0x03ce
> FAT16: entry: 0x000003cf = 975, offset: 0x03cf = 975
> FAT16: ret: 0x000003d0, entry: 0x000003cf, offset: 0x03cf
> FAT16: entry: 0x000003d0 = 976, offset: 0x03d0 = 976
> FAT16: ret: 0x000003d1, entry: 0x000003d0, offset: 0x03d0
> FAT16: entry: 0x000003d1 = 977, offset: 0x03d1 = 977
> FAT16: ret: 0x000003d2, entry: 0x000003d1, offset: 0x03d1
> FAT16: entry: 0x000003d2 = 978, offset: 0x03d2 = 978
> FAT16: ret: 0x000003d3, entry: 0x000003d2, offset: 0x03d2
> FAT16: entry: 0x000003d3 = 979, offset: 0x03d3 = 979
> FAT16: ret: 0x000003d4, entry: 0x000003d3, offset: 0x03d3
> FAT16: entry: 0x000003d4 = 980, offset: 0x03d4 = 980
> FAT16: ret: 0x000003d5, entry: 0x000003d4, offset: 0x03d4
> FAT16: entry: 0x000003d5 = 981, offset: 0x03d5 = 981
> FAT16: ret: 0x000003d6, entry: 0x000003d5, offset: 0x03d5
> FAT16: entry: 0x000003d6 = 982, offset: 0x03d6 = 982
> FAT16: ret: 0x000003d7, entry: 0x000003d6, offset: 0x03d6
> FAT16: entry: 0x000003d7 = 983, offset: 0x03d7 = 983
> FAT16: ret: 0x000003d8, entry: 0x000003d7, offset: 0x03d7
> FAT16: entry: 0x000003d8 = 984, offset: 0x03d8 = 984
> FAT16: ret: 0x000003d9, entry: 0x000003d8, offset: 0x03d8
> FAT16: entry: 0x000003d9 = 985, offset: 0x03d9 = 985
> FAT16: ret: 0x000003da, entry: 0x000003d9, offset: 0x03d9
> FAT16: entry: 0x000003da = 986, offset: 0x03da = 986
> FAT16: ret: 0x000003db, entry: 0x000003da, offset: 0x03da
> FAT16: entry: 0x000003db = 987, offset: 0x03db = 987
> FAT16: ret: 0x000003dc, entry: 0x000003db, offset: 0x03db
> FAT16: entry: 0x000003dc = 988, offset: 0x03dc = 988
> FAT16: ret: 0x000003dd, entry: 0x000003dc, offset: 0x03dc
> FAT16: entry: 0x000003dd = 989, offset: 0x03dd = 989
> FAT16: ret: 0x000003de, entry: 0x000003dd, offset: 0x03dd
> FAT16: entry: 0x000003de = 990, offset: 0x03de = 990
> FAT16: ret: 0x000003df, entry: 0x000003de, offset: 0x03de
> FAT16: entry: 0x000003df = 991, offset: 0x03df = 991
> FAT16: ret: 0x000003e0, entry: 0x000003df, offset: 0x03df
> FAT16: entry: 0x000003e0 = 992, offset: 0x03e0 = 992
> FAT16: ret: 0x000003e1, entry: 0x000003e0, offset: 0x03e0
> FAT16: entry: 0x000003e1 = 993, offset: 0x03e1 = 993
> FAT16: ret: 0x000003e2, entry: 0x000003e1, offset: 0x03e1
> FAT16: entry: 0x000003e2 = 994, offset: 0x03e2 = 994
> FAT16: ret: 0x000003e3, entry: 0x000003e2, offset: 0x03e2
> FAT16: entry: 0x000003e3 = 995, offset: 0x03e3 = 995
> FAT16: ret: 0x000003e4, entry: 0x000003e3, offset: 0x03e3
> FAT16: entry: 0x000003e4 = 996, offset: 0x03e4 = 996
> FAT16: ret: 0x000003e5, entry: 0x000003e4, offset: 0x03e4
> FAT16: entry: 0x000003e5 = 997, offset: 0x03e5 = 997
> FAT16: ret: 0x000003e6, entry: 0x000003e5, offset: 0x03e5
> FAT16: entry: 0x000003e6 = 998, offset: 0x03e6 = 998
> FAT16: ret: 0x000003e7, entry: 0x000003e6, offset: 0x03e6
> FAT16: entry: 0x000003e7 = 999, offset: 0x03e7 = 999
> FAT16: ret: 0x000003e8, entry: 0x000003e7, offset: 0x03e7
> FAT16: entry: 0x000003e8 = 1000, offset: 0x03e8 = 1000
> FAT16: ret: 0x000003e9, entry: 0x000003e8, offset: 0x03e8
> FAT16: entry: 0x000003e9 = 1001, offset: 0x03e9 = 1001
> FAT16: ret: 0x000003ea, entry: 0x000003e9, offset: 0x03e9
> FAT16: entry: 0x000003ea = 1002, offset: 0x03ea = 1002
> FAT16: ret: 0x000003eb, entry: 0x000003ea, offset: 0x03ea
> FAT16: entry: 0x000003eb = 1003, offset: 0x03eb = 1003
> FAT16: ret: 0x000003ec, entry: 0x000003eb, offset: 0x03eb
> FAT16: entry: 0x000003ec = 1004, offset: 0x03ec = 1004
> FAT16: ret: 0x000003ed, entry: 0x000003ec, offset: 0x03ec
> FAT16: entry: 0x000003ed = 1005, offset: 0x03ed = 1005
> FAT16: ret: 0x000003ee, entry: 0x000003ed, offset: 0x03ed
> FAT16: entry: 0x000003ee = 1006, offset: 0x03ee = 1006
> FAT16: ret: 0x000003ef, entry: 0x000003ee, offset: 0x03ee
> FAT16: entry: 0x000003ef = 1007, offset: 0x03ef = 1007
> FAT16: ret: 0x000003f0, entry: 0x000003ef, offset: 0x03ef
> FAT16: entry: 0x000003f0 = 1008, offset: 0x03f0 = 1008
> FAT16: ret: 0x000003f1, entry: 0x000003f0, offset: 0x03f0
> FAT16: entry: 0x000003f1 = 1009, offset: 0x03f1 = 1009
> FAT16: ret: 0x000003f2, entry: 0x000003f1, offset: 0x03f1
> FAT16: entry: 0x000003f2 = 1010, offset: 0x03f2 = 1010
> FAT16: ret: 0x000003f3, entry: 0x000003f2, offset: 0x03f2
> FAT16: entry: 0x000003f3 = 1011, offset: 0x03f3 = 1011
> FAT16: ret: 0x000003f4, entry: 0x000003f3, offset: 0x03f3
> FAT16: entry: 0x000003f4 = 1012, offset: 0x03f4 = 1012
> FAT16: ret: 0x000003f5, entry: 0x000003f4, offset: 0x03f4
> FAT16: entry: 0x000003f5 = 1013, offset: 0x03f5 = 1013
> FAT16: ret: 0x000003f6, entry: 0x000003f5, offset: 0x03f5
> FAT16: entry: 0x000003f6 = 1014, offset: 0x03f6 = 1014
> FAT16: ret: 0x000005f7, entry: 0x000003f6, offset: 0x03f6
> gc - clustnum: 751, startsect: 3429
> FAT16: entry: 0x000003f6 = 1014, offset: 0x03f6 = 1014
> FAT16: ret: 0x000005f7, entry: 0x000003f6, offset: 0x03f6
> FAT16: entry: 0x000005f7 = 1527, offset: 0x05f7 = 1527
> FAT16: ret: 0x000005f8, entry: 0x000005f7, offset: 0x05f7
> FAT16: entry: 0x000005f8 = 1528, offset: 0x05f8 = 1528
> FAT16: ret: 0x000005f9, entry: 0x000005f8, offset: 0x05f8
> FAT16: entry: 0x000005f9 = 1529, offset: 0x05f9 = 1529
> FAT16: ret: 0x000005fa, entry: 0x000005f9, offset: 0x05f9
> FAT16: entry: 0x000005fa = 1530, offset: 0x05fa = 1530
> FAT16: ret: 0x000005fb, entry: 0x000005fa, offset: 0x05fa
> FAT16: entry: 0x000005fb = 1531, offset: 0x05fb = 1531
> FAT16: ret: 0x000005fc, entry: 0x000005fb, offset: 0x05fb
> FAT16: entry: 0x000005fc = 1532, offset: 0x05fc = 1532
> FAT16: ret: 0x000005fd, entry: 0x000005fc, offset: 0x05fc
> FAT16: entry: 0x000005fd = 1533, offset: 0x05fd = 1533
> FAT16: ret: 0x000005fe, entry: 0x000005fd, offset: 0x05fd
> FAT16: entry: 0x000005fe = 1534, offset: 0x05fe = 1534
> FAT16: ret: 0x000005ff, entry: 0x000005fe, offset: 0x05fe
> FAT16: entry: 0x000005ff = 1535, offset: 0x05ff = 1535
> FAT16: ret: 0x00000600, entry: 0x000005ff, offset: 0x05ff
> FAT16: entry: 0x00000600 = 1536, offset: 0x0000 = 0
> debug: evicting 0, dirty: 0
> FAT16: ret: 0x00000601, entry: 0x00000600, offset: 0x0000
> FAT16: entry: 0x00000601 = 1537, offset: 0x0001 = 1
> FAT16: ret: 0x00000602, entry: 0x00000601, offset: 0x0001
> FAT16: entry: 0x00000602 = 1538, offset: 0x0002 = 2
> FAT16: ret: 0x00000603, entry: 0x00000602, offset: 0x0002
> FAT16: entry: 0x00000603 = 1539, offset: 0x0003 = 3
> FAT16: ret: 0x00000604, entry: 0x00000603, offset: 0x0003
> FAT16: entry: 0x00000604 = 1540, offset: 0x0004 = 4
> FAT16: ret: 0x00000605, entry: 0x00000604, offset: 0x0004
> FAT16: entry: 0x00000605 = 1541, offset: 0x0005 = 5
> FAT16: ret: 0x00000606, entry: 0x00000605, offset: 0x0005
> FAT16: entry: 0x00000606 = 1542, offset: 0x0006 = 6
> FAT16: ret: 0x00000607, entry: 0x00000606, offset: 0x0006
> FAT16: entry: 0x00000607 = 1543, offset: 0x0007 = 7
> FAT16: ret: 0x00000608, entry: 0x00000607, offset: 0x0007
> FAT16: entry: 0x00000608 = 1544, offset: 0x0008 = 8
> FAT16: ret: 0x00000609, entry: 0x00000608, offset: 0x0008
> FAT16: entry: 0x00000609 = 1545, offset: 0x0009 = 9
> FAT16: ret: 0x0000060a, entry: 0x00000609, offset: 0x0009
> FAT16: entry: 0x0000060a = 1546, offset: 0x000a = 10
> FAT16: ret: 0x0000060b, entry: 0x0000060a, offset: 0x000a
> FAT16: entry: 0x0000060b = 1547, offset: 0x000b = 11
> FAT16: ret: 0x0000060c, entry: 0x0000060b, offset: 0x000b
> FAT16: entry: 0x0000060c = 1548, offset: 0x000c = 12
> FAT16: ret: 0x0000060d, entry: 0x0000060c, offset: 0x000c
> FAT16: entry: 0x0000060d = 1549, offset: 0x000d = 13
> FAT16: ret: 0x0000060e, entry: 0x0000060d, offset: 0x000d
> FAT16: entry: 0x0000060e = 1550, offset: 0x000e = 14
> FAT16: ret: 0x0000060f, entry: 0x0000060e, offset: 0x000e
> FAT16: entry: 0x0000060f = 1551, offset: 0x000f = 15
> FAT16: ret: 0x00000610, entry: 0x0000060f, offset: 0x000f
> FAT16: entry: 0x00000610 = 1552, offset: 0x0010 = 16
> FAT16: ret: 0x00000611, entry: 0x00000610, offset: 0x0010
> FAT16: entry: 0x00000611 = 1553, offset: 0x0011 = 17
> FAT16: ret: 0x00000612, entry: 0x00000611, offset: 0x0011
> FAT16: entry: 0x00000612 = 1554, offset: 0x0012 = 18
> FAT16: ret: 0x00000613, entry: 0x00000612, offset: 0x0012
> FAT16: entry: 0x00000613 = 1555, offset: 0x0013 = 19
> FAT16: ret: 0x00000614, entry: 0x00000613, offset: 0x0013
> FAT16: entry: 0x00000614 = 1556, offset: 0x0014 = 20
> FAT16: ret: 0x00000615, entry: 0x00000614, offset: 0x0014
> FAT16: entry: 0x00000615 = 1557, offset: 0x0015 = 21
> FAT16: ret: 0x00000616, entry: 0x00000615, offset: 0x0015
> FAT16: entry: 0x00000616 = 1558, offset: 0x0016 = 22
> FAT16: ret: 0x00000617, entry: 0x00000616, offset: 0x0016
> FAT16: entry: 0x00000617 = 1559, offset: 0x0017 = 23
> FAT16: ret: 0x00000618, entry: 0x00000617, offset: 0x0017
> FAT16: entry: 0x00000618 = 1560, offset: 0x0018 = 24
> FAT16: ret: 0x00000619, entry: 0x00000618, offset: 0x0018
> FAT16: entry: 0x00000619 = 1561, offset: 0x0019 = 25
> FAT16: ret: 0x0000061a, entry: 0x00000619, offset: 0x0019
> FAT16: entry: 0x0000061a = 1562, offset: 0x001a = 26
> FAT16: ret: 0x0000061b, entry: 0x0000061a, offset: 0x001a
> FAT16: entry: 0x0000061b = 1563, offset: 0x001b = 27
> FAT16: ret: 0x0000061c, entry: 0x0000061b, offset: 0x001b
> FAT16: entry: 0x0000061c = 1564, offset: 0x001c = 28
> FAT16: ret: 0x0000061d, entry: 0x0000061c, offset: 0x001c
> FAT16: entry: 0x0000061d = 1565, offset: 0x001d = 29
> FAT16: ret: 0x0000061e, entry: 0x0000061d, offset: 0x001d
> FAT16: entry: 0x0000061e = 1566, offset: 0x001e = 30
> FAT16: ret: 0x0000061f, entry: 0x0000061e, offset: 0x001e
> FAT16: entry: 0x0000061f = 1567, offset: 0x001f = 31
> FAT16: ret: 0x00000620, entry: 0x0000061f, offset: 0x001f
> FAT16: entry: 0x00000620 = 1568, offset: 0x0020 = 32
> FAT16: ret: 0x00000621, entry: 0x00000620, offset: 0x0020
> FAT16: entry: 0x00000621 = 1569, offset: 0x0021 = 33
> FAT16: ret: 0x00000622, entry: 0x00000621, offset: 0x0021
> FAT16: entry: 0x00000622 = 1570, offset: 0x0022 = 34
> FAT16: ret: 0x00000623, entry: 0x00000622, offset: 0x0022
> FAT16: entry: 0x00000623 = 1571, offset: 0x0023 = 35
> FAT16: ret: 0x00000624, entry: 0x00000623, offset: 0x0023
> FAT16: entry: 0x00000624 = 1572, offset: 0x0024 = 36
> FAT16: ret: 0x00000625, entry: 0x00000624, offset: 0x0024
> FAT16: entry: 0x00000625 = 1573, offset: 0x0025 = 37
> FAT16: ret: 0x00000626, entry: 0x00000625, offset: 0x0025
> FAT16: entry: 0x00000626 = 1574, offset: 0x0026 = 38
> FAT16: ret: 0x00000627, entry: 0x00000626, offset: 0x0026
> FAT16: entry: 0x00000627 = 1575, offset: 0x0027 = 39
> FAT16: ret: 0x00000628, entry: 0x00000627, offset: 0x0027
> FAT16: entry: 0x00000628 = 1576, offset: 0x0028 = 40
> FAT16: ret: 0x00000629, entry: 0x00000628, offset: 0x0028
> FAT16: entry: 0x00000629 = 1577, offset: 0x0029 = 41
> FAT16: ret: 0x0000062a, entry: 0x00000629, offset: 0x0029
> FAT16: entry: 0x0000062a = 1578, offset: 0x002a = 42
> FAT16: ret: 0x0000062b, entry: 0x0000062a, offset: 0x002a
> FAT16: entry: 0x0000062b = 1579, offset: 0x002b = 43
> FAT16: ret: 0x0000062c, entry: 0x0000062b, offset: 0x002b
> gc - clustnum: 1527, startsect: 6533
> 1048576 bytes read in 5128 ms (199.2 KiB/s)
> byte at 0x83061000 (0xca) != byte at 0x82061000 (0x8f)
> Total of 397312 byte(s) were the same
> =>
>
> On 11/09/2018 08:59, Akashi, Takahiro wrote:
> > From: AKASHI Takahiro <takahiro.akashi@linaro.org>
> >
> > In this patch, all the necessary code for allowing for a file offset
> > at write is implemented. What plays a major roll here is get_set_cluster(),
> > which, in contrast to its counterpart, set_cluster(), only operates on
> > already-allocated clusters, overwriting with data.
> >
> > So, with a file offset specified, set_contents() seeks and writes data
> > with set_get_cluster() until the end of a file, and, once it reaches
> > there, continues writing with set_cluster() for the rest.
> >
> > Please note that a file will be trimmed as a result of write operation if
> > write ends before reaching file's end. This is an intended behavior
> > in order to maintain compatibility with the current interface.
> >
> > Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
> > ---
> >   fs/fat/fat_write.c | 288 ++++++++++++++++++++++++++++++++++++++++++---
> >   1 file changed, 273 insertions(+), 15 deletions(-)
> >
> > diff --git a/fs/fat/fat_write.c b/fs/fat/fat_write.c
> > index c22d8c7a46a1..651c7866debc 100644
> > --- a/fs/fat/fat_write.c
> > +++ b/fs/fat/fat_write.c
> > @@ -450,6 +450,121 @@ set_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer,
> >       return 0;
> >   }
> >
>
> _______________________________________________
> U-Boot mailing list
> U-Boot at lists.denx.de
> https://lists.denx.de/listinfo/u-boot

[U-Boot] [PATCH v3 10/26] fs: fat: support write with non-zero offset

[Alexander Graf]

On 10/31/2018 11:00 AM, Clément Péron wrote:
> Hi,
>
> Trying to rebuild my SoCFPGA Cyclone V board and got this error :
>
> fs/built-in.o: In function `set_contents':
> /home/cperon/u-boot/fs/fat/fat_write.c:831: undefined reference to
> `__aeabi_ldivmod'
> make: *** [Makefile:1381: u-boot] Error 1
>
> seems to be introduced with this operation :
> assert(!(cur_pos % bytesperclust));

Could we maybe just use a bitmask for bytesperclust?


Alex

>
> toolchain used :
> gcc version 7.3.1 20180622 (release) [ARM/embedded-7-branch revision
> 261907] (GNU Tools for Arm Embedded Processors 7-2018-q2-update)
>
> Regards,
> Clement
> On Mon, 15 Oct 2018 at 14:12, Jean-Jacques Hiblot <jjhiblot@ti.com> wrote:
>> This sometimes breaks fat writes.
>>
>> The tests is simple: load a file from tftp, write it on MMC, read it
>> back and compare
>>
>> I can provide an image of the partition if needed.
>>
>> JJ
>>
>>
>> => setenv autoload no; dhcp; setenv serverip 192.168.1.42; tftp
>> $loadaddr test; echo WRITING !; fatwrite mmc 0 $loadaddr u-boot.img
>> $filesize; mmc dev 1; mmc dev 0 ; echo READING! ; fatload mmc 0
>> 0x83000000 u-boot.img; cmp.b 0x83000000 $loadae
>> link up on port 0, speed 1000, full duplex
>> BOOTP broadcast 1
>> DHCP client bound to address 192.168.1.27 (2004 ms)
>> link up on port 0, speed 1000, full duplex
>> Using ethernet at 48484000 device
>> TFTP from server 192.168.1.42; our IP address is 192.168.1.27
>> Filename 'test'.
>> Load address: 0x82000000
>> Loading: #################################################################
>>            #######
>>            5.2 MiB/s
>> done
>> Bytes transferred = 1048576 (100000 hex)
>> WRITING !
>> writing u-boot.img
>> FAT16, fat_sect: 1, fatlength: 200
>> Rootdir begins at cluster: -6, sector: 401, offset: 32200
>> Data begins at: 425
>> Sector size: 512, cluster size: 4
>> FAT read(sect=401), clust_size=4, DIRENTSPERBLOCK=16
>> 1048576 bytes
>> FAT16: entry: 0x0000020d = 525, offset: 0x020d = 525
>> debug: evicting -1, dirty: 0
>> FAT16: ret: 0x0000020e, entry: 0x0000020d, offset: 0x020d
>> FAT16: entry: 0x0000020e = 526, offset: 0x020e = 526
>> FAT16: ret: 0x0000020f, entry: 0x0000020e, offset: 0x020e
>> FAT16: entry: 0x0000020f = 527, offset: 0x020f = 527
>> FAT16: ret: 0x00000210, entry: 0x0000020f, offset: 0x020f
>> FAT16: entry: 0x00000210 = 528, offset: 0x0210 = 528
>> FAT16: ret: 0x00000211, entry: 0x00000210, offset: 0x0210
>> FAT16: entry: 0x00000211 = 529, offset: 0x0211 = 529
>> FAT16: ret: 0x00000212, entry: 0x00000211, offset: 0x0211
>> FAT16: entry: 0x00000212 = 530, offset: 0x0212 = 530
>> FAT16: ret: 0x00000213, entry: 0x00000212, offset: 0x0212
>> FAT16: entry: 0x00000213 = 531, offset: 0x0213 = 531
>> FAT16: ret: 0x00000214, entry: 0x00000213, offset: 0x0213
>> FAT16: entry: 0x00000214 = 532, offset: 0x0214 = 532
>> FAT16: ret: 0x00000215, entry: 0x00000214, offset: 0x0214
>> FAT16: entry: 0x00000215 = 533, offset: 0x0215 = 533
>> FAT16: ret: 0x00000216, entry: 0x00000215, offset: 0x0215
>> FAT16: entry: 0x00000216 = 534, offset: 0x0216 = 534
>> FAT16: ret: 0x00000217, entry: 0x00000216, offset: 0x0216
>> FAT16: entry: 0x00000217 = 535, offset: 0x0217 = 535
>> FAT16: ret: 0x00000218, entry: 0x00000217, offset: 0x0217
>> FAT16: entry: 0x00000218 = 536, offset: 0x0218 = 536
>> FAT16: ret: 0x00000219, entry: 0x00000218, offset: 0x0218
>> FAT16: entry: 0x00000219 = 537, offset: 0x0219 = 537
>> FAT16: ret: 0x0000021a, entry: 0x00000219, offset: 0x0219
>> FAT16: entry: 0x0000021a = 538, offset: 0x021a = 538
>> FAT16: ret: 0x0000021b, entry: 0x0000021a, offset: 0x021a
>> FAT16: entry: 0x0000021b = 539, offset: 0x021b = 539
>> FAT16: ret: 0x0000021c, entry: 0x0000021b, offset: 0x021b
>> FAT16: entry: 0x0000021c = 540, offset: 0x021c = 540
>> FAT16: ret: 0x0000021d, entry: 0x0000021c, offset: 0x021c
>> FAT16: entry: 0x0000021d = 541, offset: 0x021d = 541
>> FAT16: ret: 0x0000021e, entry: 0x0000021d, offset: 0x021d
>> FAT16: entry: 0x0000021e = 542, offset: 0x021e = 542
>> FAT16: ret: 0x0000021f, entry: 0x0000021e, offset: 0x021e
>> FAT16: entry: 0x0000021f = 543, offset: 0x021f = 543
>> FAT16: ret: 0x00000220, entry: 0x0000021f, offset: 0x021f
>> FAT16: entry: 0x00000220 = 544, offset: 0x0220 = 544
>> FAT16: ret: 0x00000221, entry: 0x00000220, offset: 0x0220
>> FAT16: entry: 0x00000221 = 545, offset: 0x0221 = 545
>> FAT16: ret: 0x00000222, entry: 0x00000221, offset: 0x0221
>> FAT16: entry: 0x00000222 = 546, offset: 0x0222 = 546
>> FAT16: ret: 0x00000223, entry: 0x00000222, offset: 0x0222
>> FAT16: entry: 0x00000223 = 547, offset: 0x0223 = 547
>> FAT16: ret: 0x00000224, entry: 0x00000223, offset: 0x0223
>> FAT16: entry: 0x00000224 = 548, offset: 0x0224 = 548
>> FAT16: ret: 0x00000225, entry: 0x00000224, offset: 0x0224
>> FAT16: entry: 0x00000225 = 549, offset: 0x0225 = 549
>> FAT16: ret: 0x00000226, entry: 0x00000225, offset: 0x0225
>> FAT16: entry: 0x00000226 = 550, offset: 0x0226 = 550
>> FAT16: ret: 0x00000227, entry: 0x00000226, offset: 0x0226
>> FAT16: entry: 0x00000227 = 551, offset: 0x0227 = 551
>> FAT16: ret: 0x00000228, entry: 0x00000227, offset: 0x0227
>> FAT16: entry: 0x00000228 = 552, offset: 0x0228 = 552
>> FAT16: ret: 0x00000229, entry: 0x00000228, offset: 0x0228
>> FAT16: entry: 0x00000229 = 553, offset: 0x0229 = 553
>> FAT16: ret: 0x0000022a, entry: 0x00000229, offset: 0x0229
>> FAT16: entry: 0x0000022a = 554, offset: 0x022a = 554
>> FAT16: ret: 0x0000022b, entry: 0x0000022a, offset: 0x022a
>> FAT16: entry: 0x0000022b = 555, offset: 0x022b = 555
>> FAT16: ret: 0x0000022c, entry: 0x0000022b, offset: 0x022b
>> FAT16: entry: 0x0000022c = 556, offset: 0x022c = 556
>> FAT16: ret: 0x0000022d, entry: 0x0000022c, offset: 0x022c
>> FAT16: entry: 0x0000022d = 557, offset: 0x022d = 557
>> FAT16: ret: 0x0000022e, entry: 0x0000022d, offset: 0x022d
>> FAT16: entry: 0x0000022e = 558, offset: 0x022e = 558
>> FAT16: ret: 0x0000022f, entry: 0x0000022e, offset: 0x022e
>> FAT16: entry: 0x0000022f = 559, offset: 0x022f = 559
>> FAT16: ret: 0x00000230, entry: 0x0000022f, offset: 0x022f
>> FAT16: entry: 0x00000230 = 560, offset: 0x0230 = 560
>> FAT16: ret: 0x00000231, entry: 0x00000230, offset: 0x0230
>> FAT16: entry: 0x00000231 = 561, offset: 0x0231 = 561
>> FAT16: ret: 0x00000232, entry: 0x00000231, offset: 0x0231
>> FAT16: entry: 0x00000232 = 562, offset: 0x0232 = 562
>> FAT16: ret: 0x00000233, entry: 0x00000232, offset: 0x0232
>> FAT16: entry: 0x00000233 = 563, offset: 0x0233 = 563
>> FAT16: ret: 0x00000234, entry: 0x00000233, offset: 0x0233
>> FAT16: entry: 0x00000234 = 564, offset: 0x0234 = 564
>> FAT16: ret: 0x00000235, entry: 0x00000234, offset: 0x0234
>> FAT16: entry: 0x00000235 = 565, offset: 0x0235 = 565
>> FAT16: ret: 0x00000236, entry: 0x00000235, offset: 0x0235
>> FAT16: entry: 0x00000236 = 566, offset: 0x0236 = 566
>> FAT16: ret: 0x00000237, entry: 0x00000236, offset: 0x0236
>> FAT16: entry: 0x00000237 = 567, offset: 0x0237 = 567
>> FAT16: ret: 0x00000238, entry: 0x00000237, offset: 0x0237
>> FAT16: entry: 0x00000238 = 568, offset: 0x0238 = 568
>> FAT16: ret: 0x00000239, entry: 0x00000238, offset: 0x0238
>> FAT16: entry: 0x00000239 = 569, offset: 0x0239 = 569
>> FAT16: ret: 0x0000023a, entry: 0x00000239, offset: 0x0239
>> FAT16: entry: 0x0000023a = 570, offset: 0x023a = 570
>> FAT16: ret: 0x0000023b, entry: 0x0000023a, offset: 0x023a
>> FAT16: entry: 0x0000023b = 571, offset: 0x023b = 571
>> FAT16: ret: 0x0000023c, entry: 0x0000023b, offset: 0x023b
>> FAT16: entry: 0x0000023c = 572, offset: 0x023c = 572
>> FAT16: ret: 0x0000023d, entry: 0x0000023c, offset: 0x023c
>> FAT16: entry: 0x0000023d = 573, offset: 0x023d = 573
>> FAT16: ret: 0x0000023e, entry: 0x0000023d, offset: 0x023d
>> FAT16: entry: 0x0000023e = 574, offset: 0x023e = 574
>> FAT16: ret: 0x0000023f, entry: 0x0000023e, offset: 0x023e
>> FAT16: entry: 0x0000023f = 575, offset: 0x023f = 575
>> FAT16: ret: 0x00000240, entry: 0x0000023f, offset: 0x023f
>> FAT16: entry: 0x00000240 = 576, offset: 0x0240 = 576
>> FAT16: ret: 0x00000241, entry: 0x00000240, offset: 0x0240
>> FAT16: entry: 0x00000241 = 577, offset: 0x0241 = 577
>> FAT16: ret: 0x00000242, entry: 0x00000241, offset: 0x0241
>> FAT16: entry: 0x00000242 = 578, offset: 0x0242 = 578
>> FAT16: ret: 0x00000243, entry: 0x00000242, offset: 0x0242
>> FAT16: entry: 0x00000243 = 579, offset: 0x0243 = 579
>> FAT16: ret: 0x00000244, entry: 0x00000243, offset: 0x0243
>> FAT16: entry: 0x00000244 = 580, offset: 0x0244 = 580
>> FAT16: ret: 0x00000245, entry: 0x00000244, offset: 0x0244
>> FAT16: entry: 0x00000245 = 581, offset: 0x0245 = 581
>> FAT16: ret: 0x00000246, entry: 0x00000245, offset: 0x0245
>> FAT16: entry: 0x00000246 = 582, offset: 0x0246 = 582
>> FAT16: ret: 0x00000247, entry: 0x00000246, offset: 0x0246
>> FAT16: entry: 0x00000247 = 583, offset: 0x0247 = 583
>> FAT16: ret: 0x00000248, entry: 0x00000247, offset: 0x0247
>> FAT16: entry: 0x00000248 = 584, offset: 0x0248 = 584
>> FAT16: ret: 0x00000249, entry: 0x00000248, offset: 0x0248
>> FAT16: entry: 0x00000249 = 585, offset: 0x0249 = 585
>> FAT16: ret: 0x0000024a, entry: 0x00000249, offset: 0x0249
>> FAT16: entry: 0x0000024a = 586, offset: 0x024a = 586
>> FAT16: ret: 0x0000024b, entry: 0x0000024a, offset: 0x024a
>> FAT16: entry: 0x0000024b = 587, offset: 0x024b = 587
>> FAT16: ret: 0x0000024c, entry: 0x0000024b, offset: 0x024b
>> FAT16: entry: 0x0000024c = 588, offset: 0x024c = 588
>> FAT16: ret: 0x0000024d, entry: 0x0000024c, offset: 0x024c
>> FAT16: entry: 0x0000024d = 589, offset: 0x024d = 589
>> FAT16: ret: 0x0000024e, entry: 0x0000024d, offset: 0x024d
>> FAT16: entry: 0x0000024e = 590, offset: 0x024e = 590
>> FAT16: ret: 0x0000024f, entry: 0x0000024e, offset: 0x024e
>> FAT16: entry: 0x0000024f = 591, offset: 0x024f = 591
>> FAT16: ret: 0x00000250, entry: 0x0000024f, offset: 0x024f
>> FAT16: entry: 0x00000250 = 592, offset: 0x0250 = 592
>> FAT16: ret: 0x00000251, entry: 0x00000250, offset: 0x0250
>> FAT16: entry: 0x00000251 = 593, offset: 0x0251 = 593
>> FAT16: ret: 0x00000252, entry: 0x00000251, offset: 0x0251
>> FAT16: entry: 0x00000252 = 594, offset: 0x0252 = 594
>> FAT16: ret: 0x00000253, entry: 0x00000252, offset: 0x0252
>> FAT16: entry: 0x00000253 = 595, offset: 0x0253 = 595
>> FAT16: ret: 0x00000254, entry: 0x00000253, offset: 0x0253
>> FAT16: entry: 0x00000254 = 596, offset: 0x0254 = 596
>> FAT16: ret: 0x00000255, entry: 0x00000254, offset: 0x0254
>> FAT16: entry: 0x00000255 = 597, offset: 0x0255 = 597
>> FAT16: ret: 0x00000256, entry: 0x00000255, offset: 0x0255
>> FAT16: entry: 0x00000256 = 598, offset: 0x0256 = 598
>> FAT16: ret: 0x00000257, entry: 0x00000256, offset: 0x0256
>> FAT16: entry: 0x00000257 = 599, offset: 0x0257 = 599
>> FAT16: ret: 0x00000258, entry: 0x00000257, offset: 0x0257
>> FAT16: entry: 0x00000258 = 600, offset: 0x0258 = 600
>> FAT16: ret: 0x00000259, entry: 0x00000258, offset: 0x0258
>> FAT16: entry: 0x00000259 = 601, offset: 0x0259 = 601
>> FAT16: ret: 0x0000025a, entry: 0x00000259, offset: 0x0259
>> FAT16: entry: 0x0000025a = 602, offset: 0x025a = 602
>> FAT16: ret: 0x0000025b, entry: 0x0000025a, offset: 0x025a
>> FAT16: entry: 0x0000025b = 603, offset: 0x025b = 603
>> FAT16: ret: 0x0000025c, entry: 0x0000025b, offset: 0x025b
>> FAT16: entry: 0x0000025c = 604, offset: 0x025c = 604
>> FAT16: ret: 0x0000025d, entry: 0x0000025c, offset: 0x025c
>> FAT16: entry: 0x0000025d = 605, offset: 0x025d = 605
>> FAT16: ret: 0x0000025e, entry: 0x0000025d, offset: 0x025d
>> FAT16: entry: 0x0000025e = 606, offset: 0x025e = 606
>> FAT16: ret: 0x0000025f, entry: 0x0000025e, offset: 0x025e
>> FAT16: entry: 0x0000025f = 607, offset: 0x025f = 607
>> FAT16: ret: 0x00000260, entry: 0x0000025f, offset: 0x025f
>> FAT16: entry: 0x00000260 = 608, offset: 0x0260 = 608
>> FAT16: ret: 0x00000261, entry: 0x00000260, offset: 0x0260
>> FAT16: entry: 0x00000261 = 609, offset: 0x0261 = 609
>> FAT16: ret: 0x00000262, entry: 0x00000261, offset: 0x0261
>> FAT16: entry: 0x00000262 = 610, offset: 0x0262 = 610
>> FAT16: ret: 0x00000263, entry: 0x00000262, offset: 0x0262
>> FAT16: entry: 0x00000263 = 611, offset: 0x0263 = 611
>> FAT16: ret: 0x00000264, entry: 0x00000263, offset: 0x0263
>> FAT16: entry: 0x00000264 = 612, offset: 0x0264 = 612
>> FAT16: ret: 0x00000265, entry: 0x00000264, offset: 0x0264
>> FAT16: entry: 0x00000265 = 613, offset: 0x0265 = 613
>> FAT16: ret: 0x00000266, entry: 0x00000265, offset: 0x0265
>> FAT16: entry: 0x00000266 = 614, offset: 0x0266 = 614
>> FAT16: ret: 0x00000267, entry: 0x00000266, offset: 0x0266
>> FAT16: entry: 0x00000267 = 615, offset: 0x0267 = 615
>> FAT16: ret: 0x00000268, entry: 0x00000267, offset: 0x0267
>> FAT16: entry: 0x00000268 = 616, offset: 0x0268 = 616
>> FAT16: ret: 0x00000269, entry: 0x00000268, offset: 0x0268
>> FAT16: entry: 0x00000269 = 617, offset: 0x0269 = 617
>> FAT16: ret: 0x0000026a, entry: 0x00000269, offset: 0x0269
>> FAT16: entry: 0x0000026a = 618, offset: 0x026a = 618
>> FAT16: ret: 0x0000026b, entry: 0x0000026a, offset: 0x026a
>> FAT16: entry: 0x0000026b = 619, offset: 0x026b = 619
>> FAT16: ret: 0x0000026c, entry: 0x0000026b, offset: 0x026b
>> FAT16: entry: 0x0000026c = 620, offset: 0x026c = 620
>> FAT16: ret: 0x0000026d, entry: 0x0000026c, offset: 0x026c
>> FAT16: entry: 0x0000026d = 621, offset: 0x026d = 621
>> FAT16: ret: 0x0000026e, entry: 0x0000026d, offset: 0x026d
>> FAT16: entry: 0x0000026e = 622, offset: 0x026e = 622
>> FAT16: ret: 0x0000026f, entry: 0x0000026e, offset: 0x026e
>> FAT16: entry: 0x0000026f = 623, offset: 0x026f = 623
>> FAT16: ret: 0x00000270, entry: 0x0000026f, offset: 0x026f
>> FAT16: entry: 0x00000270 = 624, offset: 0x0270 = 624
>> FAT16: ret: 0x00000271, entry: 0x00000270, offset: 0x0270
>> FAT16: entry: 0x00000271 = 625, offset: 0x0271 = 625
>> FAT16: ret: 0x00000272, entry: 0x00000271, offset: 0x0271
>> FAT16: entry: 0x00000272 = 626, offset: 0x0272 = 626
>> FAT16: ret: 0x00000273, entry: 0x00000272, offset: 0x0272
>> FAT16: entry: 0x00000273 = 627, offset: 0x0273 = 627
>> FAT16: ret: 0x00000274, entry: 0x00000273, offset: 0x0273
>> FAT16: entry: 0x00000274 = 628, offset: 0x0274 = 628
>> FAT16: ret: 0x00000275, entry: 0x00000274, offset: 0x0274
>> FAT16: entry: 0x00000275 = 629, offset: 0x0275 = 629
>> FAT16: ret: 0x00000276, entry: 0x00000275, offset: 0x0275
>> FAT16: entry: 0x00000276 = 630, offset: 0x0276 = 630
>> FAT16: ret: 0x00000277, entry: 0x00000276, offset: 0x0276
>> FAT16: entry: 0x00000277 = 631, offset: 0x0277 = 631
>> FAT16: ret: 0x00000278, entry: 0x00000277, offset: 0x0277
>> FAT16: entry: 0x00000278 = 632, offset: 0x0278 = 632
>> FAT16: ret: 0x00000279, entry: 0x00000278, offset: 0x0278
>> FAT16: entry: 0x00000279 = 633, offset: 0x0279 = 633
>> FAT16: ret: 0x0000027a, entry: 0x00000279, offset: 0x0279
>> FAT16: entry: 0x0000027a = 634, offset: 0x027a = 634
>> FAT16: ret: 0x0000027b, entry: 0x0000027a, offset: 0x027a
>> FAT16: entry: 0x0000027b = 635, offset: 0x027b = 635
>> FAT16: ret: 0x0000027c, entry: 0x0000027b, offset: 0x027b
>> FAT16: entry: 0x0000027c = 636, offset: 0x027c = 636
>> FAT16: ret: 0x0000027d, entry: 0x0000027c, offset: 0x027c
>> FAT16: entry: 0x0000027d = 637, offset: 0x027d = 637
>> FAT16: ret: 0x0000027e, entry: 0x0000027d, offset: 0x027d
>> FAT16: entry: 0x0000027e = 638, offset: 0x027e = 638
>> FAT16: ret: 0x0000027f, entry: 0x0000027e, offset: 0x027e
>> FAT16: entry: 0x0000027f = 639, offset: 0x027f = 639
>> FAT16: ret: 0x00000280, entry: 0x0000027f, offset: 0x027f
>> FAT16: entry: 0x00000280 = 640, offset: 0x0280 = 640
>> FAT16: ret: 0x00000281, entry: 0x00000280, offset: 0x0280
>> FAT16: entry: 0x00000281 = 641, offset: 0x0281 = 641
>> FAT16: ret: 0x00000282, entry: 0x00000281, offset: 0x0281
>> FAT16: entry: 0x00000282 = 642, offset: 0x0282 = 642
>> FAT16: ret: 0x00000283, entry: 0x00000282, offset: 0x0282
>> FAT16: entry: 0x00000283 = 643, offset: 0x0283 = 643
>> FAT16: ret: 0x00000284, entry: 0x00000283, offset: 0x0283
>> FAT16: entry: 0x00000284 = 644, offset: 0x0284 = 644
>> FAT16: ret: 0x00000285, entry: 0x00000284, offset: 0x0284
>> FAT16: entry: 0x00000285 = 645, offset: 0x0285 = 645
>> FAT16: ret: 0x00000286, entry: 0x00000285, offset: 0x0285
>> FAT16: entry: 0x00000286 = 646, offset: 0x0286 = 646
>> FAT16: ret: 0x00000287, entry: 0x00000286, offset: 0x0286
>> FAT16: entry: 0x00000287 = 647, offset: 0x0287 = 647
>> FAT16: ret: 0x00000288, entry: 0x00000287, offset: 0x0287
>> FAT16: entry: 0x00000288 = 648, offset: 0x0288 = 648
>> FAT16: ret: 0x00000289, entry: 0x00000288, offset: 0x0288
>> FAT16: entry: 0x00000289 = 649, offset: 0x0289 = 649
>> FAT16: ret: 0x0000028a, entry: 0x00000289, offset: 0x0289
>> FAT16: entry: 0x0000028a = 650, offset: 0x028a = 650
>> FAT16: ret: 0x0000028b, entry: 0x0000028a, offset: 0x028a
>> FAT16: entry: 0x0000028b = 651, offset: 0x028b = 651
>> FAT16: ret: 0x0000028c, entry: 0x0000028b, offset: 0x028b
>> FAT16: entry: 0x0000028c = 652, offset: 0x028c = 652
>> FAT16: ret: 0x0000028d, entry: 0x0000028c, offset: 0x028c
>> FAT16: entry: 0x0000028d = 653, offset: 0x028d = 653
>> FAT16: ret: 0x0000028e, entry: 0x0000028d, offset: 0x028d
>> FAT16: entry: 0x0000028e = 654, offset: 0x028e = 654
>> FAT16: ret: 0x0000028f, entry: 0x0000028e, offset: 0x028e
>> FAT16: entry: 0x0000028f = 655, offset: 0x028f = 655
>> FAT16: ret: 0x00000290, entry: 0x0000028f, offset: 0x028f
>> FAT16: entry: 0x00000290 = 656, offset: 0x0290 = 656
>> FAT16: ret: 0x00000291, entry: 0x00000290, offset: 0x0290
>> FAT16: entry: 0x00000291 = 657, offset: 0x0291 = 657
>> FAT16: ret: 0x00000292, entry: 0x00000291, offset: 0x0291
>> FAT16: entry: 0x00000292 = 658, offset: 0x0292 = 658
>> FAT16: ret: 0x00000293, entry: 0x00000292, offset: 0x0292
>> FAT16: entry: 0x00000293 = 659, offset: 0x0293 = 659
>> FAT16: ret: 0x00000294, entry: 0x00000293, offset: 0x0293
>> FAT16: entry: 0x00000294 = 660, offset: 0x0294 = 660
>> FAT16: ret: 0x00000295, entry: 0x00000294, offset: 0x0294
>> FAT16: entry: 0x00000295 = 661, offset: 0x0295 = 661
>> FAT16: ret: 0x00000296, entry: 0x00000295, offset: 0x0295
>> FAT16: entry: 0x00000296 = 662, offset: 0x0296 = 662
>> FAT16: ret: 0x00000297, entry: 0x00000296, offset: 0x0296
>> FAT16: entry: 0x00000297 = 663, offset: 0x0297 = 663
>> FAT16: ret: 0x00000298, entry: 0x00000297, offset: 0x0297
>> FAT16: entry: 0x00000298 = 664, offset: 0x0298 = 664
>> FAT16: ret: 0x00000299, entry: 0x00000298, offset: 0x0298
>> FAT16: entry: 0x00000299 = 665, offset: 0x0299 = 665
>> FAT16: ret: 0x0000029a, entry: 0x00000299, offset: 0x0299
>> FAT16: entry: 0x0000029a = 666, offset: 0x029a = 666
>> FAT16: ret: 0x0000029b, entry: 0x0000029a, offset: 0x029a
>> FAT16: entry: 0x0000029b = 667, offset: 0x029b = 667
>> FAT16: ret: 0x0000029c, entry: 0x0000029b, offset: 0x029b
>> FAT16: entry: 0x0000029c = 668, offset: 0x029c = 668
>> FAT16: ret: 0x0000029d, entry: 0x0000029c, offset: 0x029c
>> FAT16: entry: 0x0000029d = 669, offset: 0x029d = 669
>> FAT16: ret: 0x0000029e, entry: 0x0000029d, offset: 0x029d
>> FAT16: entry: 0x0000029e = 670, offset: 0x029e = 670
>> FAT16: ret: 0x0000029f, entry: 0x0000029e, offset: 0x029e
>> FAT16: entry: 0x0000029f = 671, offset: 0x029f = 671
>> FAT16: ret: 0x000002a0, entry: 0x0000029f, offset: 0x029f
>> FAT16: entry: 0x000002a0 = 672, offset: 0x02a0 = 672
>> FAT16: ret: 0x000002a1, entry: 0x000002a0, offset: 0x02a0
>> FAT16: entry: 0x000002a1 = 673, offset: 0x02a1 = 673
>> FAT16: ret: 0x000002a2, entry: 0x000002a1, offset: 0x02a1
>> FAT16: entry: 0x000002a2 = 674, offset: 0x02a2 = 674
>> FAT16: ret: 0x000002a3, entry: 0x000002a2, offset: 0x02a2
>> FAT16: entry: 0x000002a3 = 675, offset: 0x02a3 = 675
>> FAT16: ret: 0x000002a4, entry: 0x000002a3, offset: 0x02a3
>> FAT16: entry: 0x000002a4 = 676, offset: 0x02a4 = 676
>> FAT16: ret: 0x000002a5, entry: 0x000002a4, offset: 0x02a4
>> FAT16: entry: 0x000002a5 = 677, offset: 0x02a5 = 677
>> FAT16: ret: 0x000002a6, entry: 0x000002a5, offset: 0x02a5
>> FAT16: entry: 0x000002a6 = 678, offset: 0x02a6 = 678
>> FAT16: ret: 0x000002a7, entry: 0x000002a6, offset: 0x02a6
>> FAT16: entry: 0x000002a7 = 679, offset: 0x02a7 = 679
>> FAT16: ret: 0x000002a8, entry: 0x000002a7, offset: 0x02a7
>> FAT16: entry: 0x000002a8 = 680, offset: 0x02a8 = 680
>> FAT16: ret: 0x000002a9, entry: 0x000002a8, offset: 0x02a8
>> FAT16: entry: 0x000002a9 = 681, offset: 0x02a9 = 681
>> FAT16: ret: 0x000002aa, entry: 0x000002a9, offset: 0x02a9
>> FAT16: entry: 0x000002aa = 682, offset: 0x02aa = 682
>> FAT16: ret: 0x000002ab, entry: 0x000002aa, offset: 0x02aa
>> FAT16: entry: 0x000002ab = 683, offset: 0x02ab = 683
>> FAT16: ret: 0x000002ac, entry: 0x000002ab, offset: 0x02ab
>> FAT16: entry: 0x000002ac = 684, offset: 0x02ac = 684
>> FAT16: ret: 0x000002ad, entry: 0x000002ac, offset: 0x02ac
>> FAT16: entry: 0x000002ad = 685, offset: 0x02ad = 685
>> FAT16: ret: 0x000002ae, entry: 0x000002ad, offset: 0x02ad
>> FAT16: entry: 0x000002ae = 686, offset: 0x02ae = 686
>> FAT16: ret: 0x000002af, entry: 0x000002ae, offset: 0x02ae
>> FAT16: entry: 0x000002af = 687, offset: 0x02af = 687
>> FAT16: ret: 0x000002b0, entry: 0x000002af, offset: 0x02af
>> FAT16: entry: 0x000002b0 = 688, offset: 0x02b0 = 688
>> FAT16: ret: 0x000002b1, entry: 0x000002b0, offset: 0x02b0
>> FAT16: entry: 0x000002b1 = 689, offset: 0x02b1 = 689
>> FAT16: ret: 0x000002b2, entry: 0x000002b1, offset: 0x02b1
>> FAT16: entry: 0x000002b2 = 690, offset: 0x02b2 = 690
>> FAT16: ret: 0x000002b3, entry: 0x000002b2, offset: 0x02b2
>> FAT16: entry: 0x000002b3 = 691, offset: 0x02b3 = 691
>> FAT16: ret: 0x000002b4, entry: 0x000002b3, offset: 0x02b3
>> FAT16: entry: 0x000002b4 = 692, offset: 0x02b4 = 692
>> FAT16: ret: 0x000002b5, entry: 0x000002b4, offset: 0x02b4
>> FAT16: entry: 0x000002b5 = 693, offset: 0x02b5 = 693
>> FAT16: ret: 0x000002b6, entry: 0x000002b5, offset: 0x02b5
>> FAT16: entry: 0x000002b6 = 694, offset: 0x02b6 = 694
>> FAT16: ret: 0x000002b7, entry: 0x000002b6, offset: 0x02b6
>> FAT16: entry: 0x000002b7 = 695, offset: 0x02b7 = 695
>> FAT16: ret: 0x000002b8, entry: 0x000002b7, offset: 0x02b7
>> FAT16: entry: 0x000002b8 = 696, offset: 0x02b8 = 696
>> FAT16: ret: 0x000002b9, entry: 0x000002b8, offset: 0x02b8
>> FAT16: entry: 0x000002b9 = 697, offset: 0x02b9 = 697
>> FAT16: ret: 0x000002ba, entry: 0x000002b9, offset: 0x02b9
>> FAT16: entry: 0x000002ba = 698, offset: 0x02ba = 698
>> FAT16: ret: 0x000002bb, entry: 0x000002ba, offset: 0x02ba
>> FAT16: entry: 0x000002bb = 699, offset: 0x02bb = 699
>> FAT16: ret: 0x000002bc, entry: 0x000002bb, offset: 0x02bb
>> FAT16: entry: 0x000002bc = 700, offset: 0x02bc = 700
>> FAT16: ret: 0x000002bd, entry: 0x000002bc, offset: 0x02bc
>> FAT16: entry: 0x000002bd = 701, offset: 0x02bd = 701
>> FAT16: ret: 0x000002be, entry: 0x000002bd, offset: 0x02bd
>> FAT16: entry: 0x000002be = 702, offset: 0x02be = 702
>> FAT16: ret: 0x000002bf, entry: 0x000002be, offset: 0x02be
>> FAT16: entry: 0x000002bf = 703, offset: 0x02bf = 703
>> FAT16: ret: 0x000002c0, entry: 0x000002bf, offset: 0x02bf
>> FAT16: entry: 0x000002c0 = 704, offset: 0x02c0 = 704
>> FAT16: ret: 0x000002c1, entry: 0x000002c0, offset: 0x02c0
>> FAT16: entry: 0x000002c1 = 705, offset: 0x02c1 = 705
>> FAT16: ret: 0x000002c2, entry: 0x000002c1, offset: 0x02c1
>> FAT16: entry: 0x000002c2 = 706, offset: 0x02c2 = 706
>> FAT16: ret: 0x000002c3, entry: 0x000002c2, offset: 0x02c2
>> FAT16: entry: 0x000002c3 = 707, offset: 0x02c3 = 707
>> FAT16: ret: 0x000002c4, entry: 0x000002c3, offset: 0x02c3
>> FAT16: entry: 0x000002c4 = 708, offset: 0x02c4 = 708
>> FAT16: ret: 0x000002c5, entry: 0x000002c4, offset: 0x02c4
>> FAT16: entry: 0x000002c5 = 709, offset: 0x02c5 = 709
>> FAT16: ret: 0x000002c6, entry: 0x000002c5, offset: 0x02c5
>> FAT16: entry: 0x000002c6 = 710, offset: 0x02c6 = 710
>> FAT16: ret: 0x000002c7, entry: 0x000002c6, offset: 0x02c6
>> FAT16: entry: 0x000002c7 = 711, offset: 0x02c7 = 711
>> FAT16: ret: 0x000002c8, entry: 0x000002c7, offset: 0x02c7
>> FAT16: entry: 0x000002c8 = 712, offset: 0x02c8 = 712
>> FAT16: ret: 0x000002c9, entry: 0x000002c8, offset: 0x02c8
>> FAT16: entry: 0x000002c9 = 713, offset: 0x02c9 = 713
>> FAT16: ret: 0x000002ca, entry: 0x000002c9, offset: 0x02c9
>> FAT16: entry: 0x000002ca = 714, offset: 0x02ca = 714
>> FAT16: ret: 0x000002cb, entry: 0x000002ca, offset: 0x02ca
>> FAT16: entry: 0x000002cb = 715, offset: 0x02cb = 715
>> FAT16: ret: 0x000002cc, entry: 0x000002cb, offset: 0x02cb
>> FAT16: entry: 0x000002cc = 716, offset: 0x02cc = 716
>> FAT16: ret: 0x000002cd, entry: 0x000002cc, offset: 0x02cc
>> FAT16: entry: 0x000002cd = 717, offset: 0x02cd = 717
>> FAT16: ret: 0x000002ce, entry: 0x000002cd, offset: 0x02cd
>> FAT16: entry: 0x000002ce = 718, offset: 0x02ce = 718
>> FAT16: ret: 0x000002ef, entry: 0x000002ce, offset: 0x02ce
>> FAT16: entry: 0x000002ef = 751, offset: 0x02ef = 751
>> FAT16: ret: 0x000002f0, entry: 0x000002ef, offset: 0x02ef
>> FAT16: entry: 0x000002f0 = 752, offset: 0x02f0 = 752
>> FAT16: ret: 0x000002f1, entry: 0x000002f0, offset: 0x02f0
>> FAT16: entry: 0x000002f1 = 753, offset: 0x02f1 = 753
>> FAT16: ret: 0x000002f2, entry: 0x000002f1, offset: 0x02f1
>> FAT16: entry: 0x000002f2 = 754, offset: 0x02f2 = 754
>> FAT16: ret: 0x000002f3, entry: 0x000002f2, offset: 0x02f2
>> FAT16: entry: 0x000002f3 = 755, offset: 0x02f3 = 755
>> FAT16: ret: 0x000002f4, entry: 0x000002f3, offset: 0x02f3
>> FAT16: entry: 0x000002f4 = 756, offset: 0x02f4 = 756
>> FAT16: ret: 0x000002f5, entry: 0x000002f4, offset: 0x02f4
>> FAT16: entry: 0x000002f5 = 757, offset: 0x02f5 = 757
>> FAT16: ret: 0x000002f6, entry: 0x000002f5, offset: 0x02f5
>> FAT16: entry: 0x000002f6 = 758, offset: 0x02f6 = 758
>> FAT16: ret: 0x000002f7, entry: 0x000002f6, offset: 0x02f6
>> FAT16: entry: 0x000002f7 = 759, offset: 0x02f7 = 759
>> FAT16: ret: 0x000002f8, entry: 0x000002f7, offset: 0x02f7
>> FAT16: entry: 0x000002f8 = 760, offset: 0x02f8 = 760
>> FAT16: ret: 0x000002f9, entry: 0x000002f8, offset: 0x02f8
>> FAT16: entry: 0x000002f9 = 761, offset: 0x02f9 = 761
>> FAT16: ret: 0x000002fa, entry: 0x000002f9, offset: 0x02f9
>> FAT16: entry: 0x000002fa = 762, offset: 0x02fa = 762
>> FAT16: ret: 0x000002fb, entry: 0x000002fa, offset: 0x02fa
>> FAT16: entry: 0x000002fb = 763, offset: 0x02fb = 763
>> FAT16: ret: 0x000002fc, entry: 0x000002fb, offset: 0x02fb
>> FAT16: entry: 0x000002fc = 764, offset: 0x02fc = 764
>> FAT16: ret: 0x000002fd, entry: 0x000002fc, offset: 0x02fc
>> FAT16: entry: 0x000002fd = 765, offset: 0x02fd = 765
>> FAT16: ret: 0x000002fe, entry: 0x000002fd, offset: 0x02fd
>> FAT16: entry: 0x000002fe = 766, offset: 0x02fe = 766
>> FAT16: ret: 0x000002ff, entry: 0x000002fe, offset: 0x02fe
>> FAT16: entry: 0x000002ff = 767, offset: 0x02ff = 767
>> FAT16: ret: 0x00000300, entry: 0x000002ff, offset: 0x02ff
>> FAT16: entry: 0x00000300 = 768, offset: 0x0300 = 768
>> FAT16: ret: 0x00000301, entry: 0x00000300, offset: 0x0300
>> FAT16: entry: 0x00000301 = 769, offset: 0x0301 = 769
>> FAT16: ret: 0x00000302, entry: 0x00000301, offset: 0x0301
>> FAT16: entry: 0x00000302 = 770, offset: 0x0302 = 770
>> FAT16: ret: 0x00000303, entry: 0x00000302, offset: 0x0302
>> FAT16: entry: 0x00000303 = 771, offset: 0x0303 = 771
>> FAT16: ret: 0x00000304, entry: 0x00000303, offset: 0x0303
>> FAT16: entry: 0x00000304 = 772, offset: 0x0304 = 772
>> FAT16: ret: 0x00000305, entry: 0x00000304, offset: 0x0304
>> FAT16: entry: 0x00000305 = 773, offset: 0x0305 = 773
>> FAT16: ret: 0x00000306, entry: 0x00000305, offset: 0x0305
>> FAT16: entry: 0x00000306 = 774, offset: 0x0306 = 774
>> FAT16: ret: 0x00000307, entry: 0x00000306, offset: 0x0306
>> FAT16: entry: 0x00000307 = 775, offset: 0x0307 = 775
>> FAT16: ret: 0x00000308, entry: 0x00000307, offset: 0x0307
>> FAT16: entry: 0x00000308 = 776, offset: 0x0308 = 776
>> FAT16: ret: 0x00000309, entry: 0x00000308, offset: 0x0308
>> FAT16: entry: 0x00000309 = 777, offset: 0x0309 = 777
>> FAT16: ret: 0x0000030a, entry: 0x00000309, offset: 0x0309
>> FAT16: entry: 0x0000030a = 778, offset: 0x030a = 778
>> FAT16: ret: 0x0000030b, entry: 0x0000030a, offset: 0x030a
>> FAT16: entry: 0x0000030b = 779, offset: 0x030b = 779
>> FAT16: ret: 0x0000030c, entry: 0x0000030b, offset: 0x030b
>> FAT16: entry: 0x0000030c = 780, offset: 0x030c = 780
>> FAT16: ret: 0x0000030d, entry: 0x0000030c, offset: 0x030c
>> FAT16: entry: 0x0000030d = 781, offset: 0x030d = 781
>> FAT16: ret: 0x0000030e, entry: 0x0000030d, offset: 0x030d
>> FAT16: entry: 0x0000030e = 782, offset: 0x030e = 782
>> FAT16: ret: 0x0000030f, entry: 0x0000030e, offset: 0x030e
>> FAT16: entry: 0x0000030f = 783, offset: 0x030f = 783
>> FAT16: ret: 0x00000310, entry: 0x0000030f, offset: 0x030f
>> FAT16: entry: 0x00000310 = 784, offset: 0x0310 = 784
>> FAT16: ret: 0x00000311, entry: 0x00000310, offset: 0x0310
>> FAT16: entry: 0x00000311 = 785, offset: 0x0311 = 785
>> FAT16: ret: 0x00000312, entry: 0x00000311, offset: 0x0311
>> FAT16: entry: 0x00000312 = 786, offset: 0x0312 = 786
>> FAT16: ret: 0x00000313, entry: 0x00000312, offset: 0x0312
>> FAT16: entry: 0x00000313 = 787, offset: 0x0313 = 787
>> FAT16: ret: 0x00000314, entry: 0x00000313, offset: 0x0313
>> FAT16: entry: 0x00000314 = 788, offset: 0x0314 = 788
>> FAT16: ret: 0x00000315, entry: 0x00000314, offset: 0x0314
>> FAT16: entry: 0x00000315 = 789, offset: 0x0315 = 789
>> FAT16: ret: 0x00000316, entry: 0x00000315, offset: 0x0315
>> FAT16: entry: 0x00000316 = 790, offset: 0x0316 = 790
>> FAT16: ret: 0x00000317, entry: 0x00000316, offset: 0x0316
>> FAT16: entry: 0x00000317 = 791, offset: 0x0317 = 791
>> FAT16: ret: 0x00000318, entry: 0x00000317, offset: 0x0317
>> FAT16: entry: 0x00000318 = 792, offset: 0x0318 = 792
>> FAT16: ret: 0x00000319, entry: 0x00000318, offset: 0x0318
>> FAT16: entry: 0x00000319 = 793, offset: 0x0319 = 793
>> FAT16: ret: 0x0000031a, entry: 0x00000319, offset: 0x0319
>> FAT16: entry: 0x0000031a = 794, offset: 0x031a = 794
>> FAT16: ret: 0x0000031b, entry: 0x0000031a, offset: 0x031a
>> FAT16: entry: 0x0000031b = 795, offset: 0x031b = 795
>> FAT16: ret: 0x0000031c, entry: 0x0000031b, offset: 0x031b
>> FAT16: entry: 0x0000031c = 796, offset: 0x031c = 796
>> FAT16: ret: 0x0000031d, entry: 0x0000031c, offset: 0x031c
>> FAT16: entry: 0x0000031d = 797, offset: 0x031d = 797
>> FAT16: ret: 0x0000031e, entry: 0x0000031d, offset: 0x031d
>> FAT16: entry: 0x0000031e = 798, offset: 0x031e = 798
>> FAT16: ret: 0x0000031f, entry: 0x0000031e, offset: 0x031e
>> FAT16: entry: 0x0000031f = 799, offset: 0x031f = 799
>> FAT16: ret: 0x00000320, entry: 0x0000031f, offset: 0x031f
>> FAT16: entry: 0x00000320 = 800, offset: 0x0320 = 800
>> FAT16: ret: 0x00000321, entry: 0x00000320, offset: 0x0320
>> FAT16: entry: 0x00000321 = 801, offset: 0x0321 = 801
>> FAT16: ret: 0x00000322, entry: 0x00000321, offset: 0x0321
>> FAT16: entry: 0x00000322 = 802, offset: 0x0322 = 802
>> FAT16: ret: 0x00000323, entry: 0x00000322, offset: 0x0322
>> FAT16: entry: 0x00000323 = 803, offset: 0x0323 = 803
>> FAT16: ret: 0x00000324, entry: 0x00000323, offset: 0x0323
>> FAT16: entry: 0x00000324 = 804, offset: 0x0324 = 804
>> FAT16: ret: 0x00000325, entry: 0x00000324, offset: 0x0324
>> FAT16: entry: 0x00000325 = 805, offset: 0x0325 = 805
>> FAT16: ret: 0x00000326, entry: 0x00000325, offset: 0x0325
>> FAT16: entry: 0x00000326 = 806, offset: 0x0326 = 806
>> FAT16: ret: 0x00000327, entry: 0x00000326, offset: 0x0326
>> FAT16: entry: 0x00000327 = 807, offset: 0x0327 = 807
>> FAT16: ret: 0x00000328, entry: 0x00000327, offset: 0x0327
>> FAT16: entry: 0x00000328 = 808, offset: 0x0328 = 808
>> FAT16: ret: 0x00000329, entry: 0x00000328, offset: 0x0328
>> FAT16: entry: 0x00000329 = 809, offset: 0x0329 = 809
>> FAT16: ret: 0x0000032a, entry: 0x00000329, offset: 0x0329
>> FAT16: entry: 0x0000032a = 810, offset: 0x032a = 810
>> FAT16: ret: 0x0000032b, entry: 0x0000032a, offset: 0x032a
>> FAT16: entry: 0x0000032b = 811, offset: 0x032b = 811
>> FAT16: ret: 0x0000032c, entry: 0x0000032b, offset: 0x032b
>> FAT16: entry: 0x0000032c = 812, offset: 0x032c = 812
>> FAT16: ret: 0x0000032d, entry: 0x0000032c, offset: 0x032c
>> FAT16: entry: 0x0000032d = 813, offset: 0x032d = 813
>> FAT16: ret: 0x0000032e, entry: 0x0000032d, offset: 0x032d
>> FAT16: entry: 0x0000032e = 814, offset: 0x032e = 814
>> FAT16: ret: 0x0000032f, entry: 0x0000032e, offset: 0x032e
>> FAT16: entry: 0x0000032f = 815, offset: 0x032f = 815
>> FAT16: ret: 0x00000330, entry: 0x0000032f, offset: 0x032f
>> FAT16: entry: 0x00000330 = 816, offset: 0x0330 = 816
>> FAT16: ret: 0x00000331, entry: 0x00000330, offset: 0x0330
>> FAT16: entry: 0x00000331 = 817, offset: 0x0331 = 817
>> FAT16: ret: 0x00000332, entry: 0x00000331, offset: 0x0331
>> FAT16: entry: 0x00000332 = 818, offset: 0x0332 = 818
>> FAT16: ret: 0x00000333, entry: 0x00000332, offset: 0x0332
>> FAT16: entry: 0x00000333 = 819, offset: 0x0333 = 819
>> FAT16: ret: 0x00000334, entry: 0x00000333, offset: 0x0333
>> FAT16: entry: 0x00000334 = 820, offset: 0x0334 = 820
>> FAT16: ret: 0x00000335, entry: 0x00000334, offset: 0x0334
>> FAT16: entry: 0x00000335 = 821, offset: 0x0335 = 821
>> FAT16: ret: 0x00000336, entry: 0x00000335, offset: 0x0335
>> FAT16: entry: 0x00000336 = 822, offset: 0x0336 = 822
>> FAT16: ret: 0x00000337, entry: 0x00000336, offset: 0x0336
>> FAT16: entry: 0x00000337 = 823, offset: 0x0337 = 823
>> FAT16: ret: 0x00000338, entry: 0x00000337, offset: 0x0337
>> FAT16: entry: 0x00000338 = 824, offset: 0x0338 = 824
>> FAT16: ret: 0x00000339, entry: 0x00000338, offset: 0x0338
>> FAT16: entry: 0x00000339 = 825, offset: 0x0339 = 825
>> FAT16: ret: 0x0000033a, entry: 0x00000339, offset: 0x0339
>> FAT16: entry: 0x0000033a = 826, offset: 0x033a = 826
>> FAT16: ret: 0x0000033b, entry: 0x0000033a, offset: 0x033a
>> FAT16: entry: 0x0000033b = 827, offset: 0x033b = 827
>> FAT16: ret: 0x0000033c, entry: 0x0000033b, offset: 0x033b
>> FAT16: entry: 0x0000033c = 828, offset: 0x033c = 828
>> FAT16: ret: 0x0000033d, entry: 0x0000033c, offset: 0x033c
>> FAT16: entry: 0x0000033d = 829, offset: 0x033d = 829
>> FAT16: ret: 0x0000033e, entry: 0x0000033d, offset: 0x033d
>> FAT16: entry: 0x0000033e = 830, offset: 0x033e = 830
>> FAT16: ret: 0x0000033f, entry: 0x0000033e, offset: 0x033e
>> FAT16: entry: 0x0000033f = 831, offset: 0x033f = 831
>> FAT16: ret: 0x00000340, entry: 0x0000033f, offset: 0x033f
>> FAT16: entry: 0x00000340 = 832, offset: 0x0340 = 832
>> FAT16: ret: 0x00000341, entry: 0x00000340, offset: 0x0340
>> FAT16: entry: 0x00000341 = 833, offset: 0x0341 = 833
>> FAT16: ret: 0x00000342, entry: 0x00000341, offset: 0x0341
>> FAT16: entry: 0x00000342 = 834, offset: 0x0342 = 834
>> FAT16: ret: 0x00000343, entry: 0x00000342, offset: 0x0342
>> FAT16: entry: 0x00000343 = 835, offset: 0x0343 = 835
>> FAT16: ret: 0x00000344, entry: 0x00000343, offset: 0x0343
>> FAT16: entry: 0x00000344 = 836, offset: 0x0344 = 836
>> FAT16: ret: 0x00000345, entry: 0x00000344, offset: 0x0344
>> FAT16: entry: 0x00000345 = 837, offset: 0x0345 = 837
>> FAT16: ret: 0x00000346, entry: 0x00000345, offset: 0x0345
>> FAT16: entry: 0x00000346 = 838, offset: 0x0346 = 838
>> FAT16: ret: 0x00000347, entry: 0x00000346, offset: 0x0346
>> FAT16: entry: 0x00000347 = 839, offset: 0x0347 = 839
>> FAT16: ret: 0x00000348, entry: 0x00000347, offset: 0x0347
>> FAT16: entry: 0x00000348 = 840, offset: 0x0348 = 840
>> FAT16: ret: 0x00000349, entry: 0x00000348, offset: 0x0348
>> FAT16: entry: 0x00000349 = 841, offset: 0x0349 = 841
>> FAT16: ret: 0x0000034a, entry: 0x00000349, offset: 0x0349
>> FAT16: entry: 0x0000034a = 842, offset: 0x034a = 842
>> FAT16: ret: 0x0000034b, entry: 0x0000034a, offset: 0x034a
>> FAT16: entry: 0x0000034b = 843, offset: 0x034b = 843
>> FAT16: ret: 0x0000034c, entry: 0x0000034b, offset: 0x034b
>> FAT16: entry: 0x0000034c = 844, offset: 0x034c = 844
>> FAT16: ret: 0x0000034d, entry: 0x0000034c, offset: 0x034c
>> FAT16: entry: 0x0000034d = 845, offset: 0x034d = 845
>> FAT16: ret: 0x0000034e, entry: 0x0000034d, offset: 0x034d
>> FAT16: entry: 0x0000034e = 846, offset: 0x034e = 846
>> FAT16: ret: 0x0000034f, entry: 0x0000034e, offset: 0x034e
>> FAT16: entry: 0x0000034f = 847, offset: 0x034f = 847
>> FAT16: ret: 0x00000350, entry: 0x0000034f, offset: 0x034f
>> FAT16: entry: 0x00000350 = 848, offset: 0x0350 = 848
>> FAT16: ret: 0x00000351, entry: 0x00000350, offset: 0x0350
>> FAT16: entry: 0x00000351 = 849, offset: 0x0351 = 849
>> FAT16: ret: 0x00000352, entry: 0x00000351, offset: 0x0351
>> FAT16: entry: 0x00000352 = 850, offset: 0x0352 = 850
>> FAT16: ret: 0x00000353, entry: 0x00000352, offset: 0x0352
>> FAT16: entry: 0x00000353 = 851, offset: 0x0353 = 851
>> FAT16: ret: 0x00000354, entry: 0x00000353, offset: 0x0353
>> FAT16: entry: 0x00000354 = 852, offset: 0x0354 = 852
>> FAT16: ret: 0x00000355, entry: 0x00000354, offset: 0x0354
>> FAT16: entry: 0x00000355 = 853, offset: 0x0355 = 853
>> FAT16: ret: 0x00000356, entry: 0x00000355, offset: 0x0355
>> FAT16: entry: 0x00000356 = 854, offset: 0x0356 = 854
>> FAT16: ret: 0x00000357, entry: 0x00000356, offset: 0x0356
>> FAT16: entry: 0x00000357 = 855, offset: 0x0357 = 855
>> FAT16: ret: 0x00000358, entry: 0x00000357, offset: 0x0357
>> FAT16: entry: 0x00000358 = 856, offset: 0x0358 = 856
>> FAT16: ret: 0x00000359, entry: 0x00000358, offset: 0x0358
>> FAT16: entry: 0x00000359 = 857, offset: 0x0359 = 857
>> FAT16: ret: 0x0000035a, entry: 0x00000359, offset: 0x0359
>> FAT16: entry: 0x0000035a = 858, offset: 0x035a = 858
>> FAT16: ret: 0x0000035b, entry: 0x0000035a, offset: 0x035a
>> FAT16: entry: 0x0000035b = 859, offset: 0x035b = 859
>> FAT16: ret: 0x0000035c, entry: 0x0000035b, offset: 0x035b
>> FAT16: entry: 0x0000035c = 860, offset: 0x035c = 860
>> FAT16: ret: 0x0000035d, entry: 0x0000035c, offset: 0x035c
>> FAT16: entry: 0x0000035d = 861, offset: 0x035d = 861
>> FAT16: ret: 0x0000035e, entry: 0x0000035d, offset: 0x035d
>> FAT16: entry: 0x0000035e = 862, offset: 0x035e = 862
>> FAT16: ret: 0x0000035f, entry: 0x0000035e, offset: 0x035e
>> FAT16: entry: 0x0000035f = 863, offset: 0x035f = 863
>> FAT16: ret: 0x00000360, entry: 0x0000035f, offset: 0x035f
>> FAT16: entry: 0x00000360 = 864, offset: 0x0360 = 864
>> FAT16: ret: 0x00000361, entry: 0x00000360, offset: 0x0360
>> FAT16: entry: 0x00000361 = 865, offset: 0x0361 = 865
>> FAT16: ret: 0x00000362, entry: 0x00000361, offset: 0x0361
>> FAT16: entry: 0x00000362 = 866, offset: 0x0362 = 866
>> FAT16: ret: 0x00000363, entry: 0x00000362, offset: 0x0362
>> FAT16: entry: 0x00000363 = 867, offset: 0x0363 = 867
>> FAT16: ret: 0x00000364, entry: 0x00000363, offset: 0x0363
>> FAT16: entry: 0x00000364 = 868, offset: 0x0364 = 868
>> FAT16: ret: 0x00000365, entry: 0x00000364, offset: 0x0364
>> FAT16: entry: 0x00000365 = 869, offset: 0x0365 = 869
>> FAT16: ret: 0x00000366, entry: 0x00000365, offset: 0x0365
>> FAT16: entry: 0x00000366 = 870, offset: 0x0366 = 870
>> FAT16: ret: 0x00000367, entry: 0x00000366, offset: 0x0366
>> FAT16: entry: 0x00000367 = 871, offset: 0x0367 = 871
>> FAT16: ret: 0x00000368, entry: 0x00000367, offset: 0x0367
>> FAT16: entry: 0x00000368 = 872, offset: 0x0368 = 872
>> FAT16: ret: 0x00000369, entry: 0x00000368, offset: 0x0368
>> FAT16: entry: 0x00000369 = 873, offset: 0x0369 = 873
>> FAT16: ret: 0x0000036a, entry: 0x00000369, offset: 0x0369
>> FAT16: entry: 0x0000036a = 874, offset: 0x036a = 874
>> FAT16: ret: 0x0000036b, entry: 0x0000036a, offset: 0x036a
>> FAT16: entry: 0x0000036b = 875, offset: 0x036b = 875
>> FAT16: ret: 0x0000036c, entry: 0x0000036b, offset: 0x036b
>> FAT16: entry: 0x0000036c = 876, offset: 0x036c = 876
>> FAT16: ret: 0x0000036d, entry: 0x0000036c, offset: 0x036c
>> FAT16: entry: 0x0000036d = 877, offset: 0x036d = 877
>> FAT16: ret: 0x0000036e, entry: 0x0000036d, offset: 0x036d
>> FAT16: entry: 0x0000036e = 878, offset: 0x036e = 878
>> FAT16: ret: 0x0000036f, entry: 0x0000036e, offset: 0x036e
>> FAT16: entry: 0x0000036f = 879, offset: 0x036f = 879
>> FAT16: ret: 0x00000370, entry: 0x0000036f, offset: 0x036f
>> FAT16: entry: 0x00000370 = 880, offset: 0x0370 = 880
>> FAT16: ret: 0x00000371, entry: 0x00000370, offset: 0x0370
>> FAT16: entry: 0x00000371 = 881, offset: 0x0371 = 881
>> FAT16: ret: 0x00000372, entry: 0x00000371, offset: 0x0371
>> FAT16: entry: 0x00000372 = 882, offset: 0x0372 = 882
>> FAT16: ret: 0x00000373, entry: 0x00000372, offset: 0x0372
>> FAT16: entry: 0x00000373 = 883, offset: 0x0373 = 883
>> FAT16: ret: 0x00000374, entry: 0x00000373, offset: 0x0373
>> FAT16: entry: 0x00000374 = 884, offset: 0x0374 = 884
>> FAT16: ret: 0x00000375, entry: 0x00000374, offset: 0x0374
>> FAT16: entry: 0x00000375 = 885, offset: 0x0375 = 885
>> FAT16: ret: 0x00000376, entry: 0x00000375, offset: 0x0375
>> FAT16: entry: 0x00000376 = 886, offset: 0x0376 = 886
>> FAT16: ret: 0x00000377, entry: 0x00000376, offset: 0x0376
>> FAT16: entry: 0x00000377 = 887, offset: 0x0377 = 887
>> FAT16: ret: 0x00000378, entry: 0x00000377, offset: 0x0377
>> FAT16: entry: 0x00000378 = 888, offset: 0x0378 = 888
>> FAT16: ret: 0x00000379, entry: 0x00000378, offset: 0x0378
>> FAT16: entry: 0x00000379 = 889, offset: 0x0379 = 889
>> FAT16: ret: 0x0000037a, entry: 0x00000379, offset: 0x0379
>> FAT16: entry: 0x0000037a = 890, offset: 0x037a = 890
>> FAT16: ret: 0x0000037b, entry: 0x0000037a, offset: 0x037a
>> FAT16: entry: 0x0000037b = 891, offset: 0x037b = 891
>> FAT16: ret: 0x0000037c, entry: 0x0000037b, offset: 0x037b
>> FAT16: entry: 0x0000037c = 892, offset: 0x037c = 892
>> FAT16: ret: 0x0000037d, entry: 0x0000037c, offset: 0x037c
>> FAT16: entry: 0x0000037d = 893, offset: 0x037d = 893
>> FAT16: ret: 0x0000037e, entry: 0x0000037d, offset: 0x037d
>> FAT16: entry: 0x0000037e = 894, offset: 0x037e = 894
>> FAT16: ret: 0x0000037f, entry: 0x0000037e, offset: 0x037e
>> FAT16: entry: 0x0000037f = 895, offset: 0x037f = 895
>> FAT16: ret: 0x00000380, entry: 0x0000037f, offset: 0x037f
>> FAT16: entry: 0x00000380 = 896, offset: 0x0380 = 896
>> FAT16: ret: 0x00000381, entry: 0x00000380, offset: 0x0380
>> FAT16: entry: 0x00000381 = 897, offset: 0x0381 = 897
>> FAT16: ret: 0x00000382, entry: 0x00000381, offset: 0x0381
>> FAT16: entry: 0x00000382 = 898, offset: 0x0382 = 898
>> FAT16: ret: 0x00000383, entry: 0x00000382, offset: 0x0382
>> FAT16: entry: 0x00000383 = 899, offset: 0x0383 = 899
>> FAT16: ret: 0x00000384, entry: 0x00000383, offset: 0x0383
>> FAT16: entry: 0x00000384 = 900, offset: 0x0384 = 900
>> FAT16: ret: 0x00000385, entry: 0x00000384, offset: 0x0384
>> FAT16: entry: 0x00000385 = 901, offset: 0x0385 = 901
>> FAT16: ret: 0x00000386, entry: 0x00000385, offset: 0x0385
>> FAT16: entry: 0x00000386 = 902, offset: 0x0386 = 902
>> FAT16: ret: 0x00000387, entry: 0x00000386, offset: 0x0386
>> FAT16: entry: 0x00000387 = 903, offset: 0x0387 = 903
>> FAT16: ret: 0x00000388, entry: 0x00000387, offset: 0x0387
>> FAT16: entry: 0x00000388 = 904, offset: 0x0388 = 904
>> FAT16: ret: 0x00000389, entry: 0x00000388, offset: 0x0388
>> FAT16: entry: 0x00000389 = 905, offset: 0x0389 = 905
>> FAT16: ret: 0x0000038a, entry: 0x00000389, offset: 0x0389
>> FAT16: entry: 0x0000038a = 906, offset: 0x038a = 906
>> FAT16: ret: 0x0000038b, entry: 0x0000038a, offset: 0x038a
>> FAT16: entry: 0x0000038b = 907, offset: 0x038b = 907
>> FAT16: ret: 0x0000038c, entry: 0x0000038b, offset: 0x038b
>> FAT16: entry: 0x0000038c = 908, offset: 0x038c = 908
>> FAT16: ret: 0x0000038d, entry: 0x0000038c, offset: 0x038c
>> FAT16: entry: 0x0000038d = 909, offset: 0x038d = 909
>> FAT16: ret: 0x0000038e, entry: 0x0000038d, offset: 0x038d
>> FAT16: entry: 0x0000038e = 910, offset: 0x038e = 910
>> FAT16: ret: 0x0000038f, entry: 0x0000038e, offset: 0x038e
>> FAT16: entry: 0x0000038f = 911, offset: 0x038f = 911
>> FAT16: ret: 0x00000390, entry: 0x0000038f, offset: 0x038f
>> FAT16: entry: 0x00000390 = 912, offset: 0x0390 = 912
>> FAT16: ret: 0x00000391, entry: 0x00000390, offset: 0x0390
>> FAT16: entry: 0x00000391 = 913, offset: 0x0391 = 913
>> FAT16: ret: 0x00000392, entry: 0x00000391, offset: 0x0391
>> FAT16: entry: 0x00000392 = 914, offset: 0x0392 = 914
>> FAT16: ret: 0x00000393, entry: 0x00000392, offset: 0x0392
>> FAT16: entry: 0x00000393 = 915, offset: 0x0393 = 915
>> FAT16: ret: 0x00000394, entry: 0x00000393, offset: 0x0393
>> FAT16: entry: 0x00000394 = 916, offset: 0x0394 = 916
>> FAT16: ret: 0x00000395, entry: 0x00000394, offset: 0x0394
>> FAT16: entry: 0x00000395 = 917, offset: 0x0395 = 917
>> FAT16: ret: 0x00000396, entry: 0x00000395, offset: 0x0395
>> FAT16: entry: 0x00000396 = 918, offset: 0x0396 = 918
>> FAT16: ret: 0x00000397, entry: 0x00000396, offset: 0x0396
>> FAT16: entry: 0x00000397 = 919, offset: 0x0397 = 919
>> FAT16: ret: 0x00000398, entry: 0x00000397, offset: 0x0397
>> FAT16: entry: 0x00000398 = 920, offset: 0x0398 = 920
>> FAT16: ret: 0x00000399, entry: 0x00000398, offset: 0x0398
>> FAT16: entry: 0x00000399 = 921, offset: 0x0399 = 921
>> FAT16: ret: 0x0000039a, entry: 0x00000399, offset: 0x0399
>> FAT16: entry: 0x0000039a = 922, offset: 0x039a = 922
>> FAT16: ret: 0x0000039b, entry: 0x0000039a, offset: 0x039a
>> FAT16: entry: 0x0000039b = 923, offset: 0x039b = 923
>> FAT16: ret: 0x0000039c, entry: 0x0000039b, offset: 0x039b
>> FAT16: entry: 0x0000039c = 924, offset: 0x039c = 924
>> FAT16: ret: 0x0000039d, entry: 0x0000039c, offset: 0x039c
>> FAT16: entry: 0x0000039d = 925, offset: 0x039d = 925
>> FAT16: ret: 0x0000039e, entry: 0x0000039d, offset: 0x039d
>> FAT16: entry: 0x0000039e = 926, offset: 0x039e = 926
>> FAT16: ret: 0x0000039f, entry: 0x0000039e, offset: 0x039e
>> FAT16: entry: 0x0000039f = 927, offset: 0x039f = 927
>> FAT16: ret: 0x000003a0, entry: 0x0000039f, offset: 0x039f
>> FAT16: entry: 0x000003a0 = 928, offset: 0x03a0 = 928
>> FAT16: ret: 0x000003a1, entry: 0x000003a0, offset: 0x03a0
>> FAT16: entry: 0x000003a1 = 929, offset: 0x03a1 = 929
>> FAT16: ret: 0x000003a2, entry: 0x000003a1, offset: 0x03a1
>> FAT16: entry: 0x000003a2 = 930, offset: 0x03a2 = 930
>> FAT16: ret: 0x000003a3, entry: 0x000003a2, offset: 0x03a2
>> FAT16: entry: 0x000003a3 = 931, offset: 0x03a3 = 931
>> FAT16: ret: 0x000003a4, entry: 0x000003a3, offset: 0x03a3
>> FAT16: entry: 0x000003a4 = 932, offset: 0x03a4 = 932
>> FAT16: ret: 0x000003a5, entry: 0x000003a4, offset: 0x03a4
>> FAT16: entry: 0x000003a5 = 933, offset: 0x03a5 = 933
>> FAT16: ret: 0x000003a6, entry: 0x000003a5, offset: 0x03a5
>> FAT16: entry: 0x000003a6 = 934, offset: 0x03a6 = 934
>> FAT16: ret: 0x000003a7, entry: 0x000003a6, offset: 0x03a6
>> FAT16: entry: 0x000003a7 = 935, offset: 0x03a7 = 935
>> FAT16: ret: 0x000003a8, entry: 0x000003a7, offset: 0x03a7
>> FAT16: entry: 0x000003a8 = 936, offset: 0x03a8 = 936
>> FAT16: ret: 0x000003a9, entry: 0x000003a8, offset: 0x03a8
>> FAT16: entry: 0x000003a9 = 937, offset: 0x03a9 = 937
>> FAT16: ret: 0x000003aa, entry: 0x000003a9, offset: 0x03a9
>> FAT16: entry: 0x000003aa = 938, offset: 0x03aa = 938
>> FAT16: ret: 0x000003ab, entry: 0x000003aa, offset: 0x03aa
>> FAT16: entry: 0x000003ab = 939, offset: 0x03ab = 939
>> FAT16: ret: 0x000003ac, entry: 0x000003ab, offset: 0x03ab
>> FAT16: entry: 0x000003ac = 940, offset: 0x03ac = 940
>> FAT16: ret: 0x000003ad, entry: 0x000003ac, offset: 0x03ac
>> FAT16: entry: 0x000003ad = 941, offset: 0x03ad = 941
>> FAT16: ret: 0x000003ae, entry: 0x000003ad, offset: 0x03ad
>> FAT16: entry: 0x000003ae = 942, offset: 0x03ae = 942
>> FAT16: ret: 0x000003af, entry: 0x000003ae, offset: 0x03ae
>> FAT16: entry: 0x000003af = 943, offset: 0x03af = 943
>> FAT16: ret: 0x000003b0, entry: 0x000003af, offset: 0x03af
>> FAT16: entry: 0x000003b0 = 944, offset: 0x03b0 = 944
>> FAT16: ret: 0x000003b1, entry: 0x000003b0, offset: 0x03b0
>> FAT16: entry: 0x000003b1 = 945, offset: 0x03b1 = 945
>> FAT16: ret: 0x000003b2, entry: 0x000003b1, offset: 0x03b1
>> FAT16: entry: 0x000003b2 = 946, offset: 0x03b2 = 946
>> FAT16: ret: 0x000003b3, entry: 0x000003b2, offset: 0x03b2
>> FAT16: entry: 0x000003b3 = 947, offset: 0x03b3 = 947
>> FAT16: ret: 0x000003b4, entry: 0x000003b3, offset: 0x03b3
>> FAT16: entry: 0x000003b4 = 948, offset: 0x03b4 = 948
>> FAT16: ret: 0x000003b5, entry: 0x000003b4, offset: 0x03b4
>> FAT16: entry: 0x000003b5 = 949, offset: 0x03b5 = 949
>> FAT16: ret: 0x000003b6, entry: 0x000003b5, offset: 0x03b5
>> FAT16: entry: 0x000003b6 = 950, offset: 0x03b6 = 950
>> FAT16: ret: 0x000003b7, entry: 0x000003b6, offset: 0x03b6
>> FAT16: entry: 0x000003b7 = 951, offset: 0x03b7 = 951
>> FAT16: ret: 0x000003b8, entry: 0x000003b7, offset: 0x03b7
>> FAT16: entry: 0x000003b8 = 952, offset: 0x03b8 = 952
>> FAT16: ret: 0x000003b9, entry: 0x000003b8, offset: 0x03b8
>> FAT16: entry: 0x000003b9 = 953, offset: 0x03b9 = 953
>> FAT16: ret: 0x000003ba, entry: 0x000003b9, offset: 0x03b9
>> FAT16: entry: 0x000003ba = 954, offset: 0x03ba = 954
>> FAT16: ret: 0x000003bb, entry: 0x000003ba, offset: 0x03ba
>> FAT16: entry: 0x000003bb = 955, offset: 0x03bb = 955
>> FAT16: ret: 0x000003bc, entry: 0x000003bb, offset: 0x03bb
>> FAT16: entry: 0x000003bc = 956, offset: 0x03bc = 956
>> FAT16: ret: 0x000003bd, entry: 0x000003bc, offset: 0x03bc
>> FAT16: entry: 0x000003bd = 957, offset: 0x03bd = 957
>> FAT16: ret: 0x000003be, entry: 0x000003bd, offset: 0x03bd
>> FAT16: entry: 0x000003be = 958, offset: 0x03be = 958
>> FAT16: ret: 0x000003bf, entry: 0x000003be, offset: 0x03be
>> FAT16: entry: 0x000003bf = 959, offset: 0x03bf = 959
>> FAT16: ret: 0x000003c0, entry: 0x000003bf, offset: 0x03bf
>> FAT16: entry: 0x000003c0 = 960, offset: 0x03c0 = 960
>> FAT16: ret: 0x000003c1, entry: 0x000003c0, offset: 0x03c0
>> FAT16: entry: 0x000003c1 = 961, offset: 0x03c1 = 961
>> FAT16: ret: 0x000003c2, entry: 0x000003c1, offset: 0x03c1
>> FAT16: entry: 0x000003c2 = 962, offset: 0x03c2 = 962
>> FAT16: ret: 0x000003c3, entry: 0x000003c2, offset: 0x03c2
>> FAT16: entry: 0x000003c3 = 963, offset: 0x03c3 = 963
>> FAT16: ret: 0x000003c4, entry: 0x000003c3, offset: 0x03c3
>> FAT16: entry: 0x000003c4 = 964, offset: 0x03c4 = 964
>> FAT16: ret: 0x000003c5, entry: 0x000003c4, offset: 0x03c4
>> FAT16: entry: 0x000003c5 = 965, offset: 0x03c5 = 965
>> FAT16: ret: 0x000003c6, entry: 0x000003c5, offset: 0x03c5
>> FAT16: entry: 0x000003c6 = 966, offset: 0x03c6 = 966
>> FAT16: ret: 0x000003c7, entry: 0x000003c6, offset: 0x03c6
>> FAT16: entry: 0x000003c7 = 967, offset: 0x03c7 = 967
>> FAT16: ret: 0x000003c8, entry: 0x000003c7, offset: 0x03c7
>> FAT16: entry: 0x000003c8 = 968, offset: 0x03c8 = 968
>> FAT16: ret: 0x000003c9, entry: 0x000003c8, offset: 0x03c8
>> FAT16: entry: 0x000003c9 = 969, offset: 0x03c9 = 969
>> FAT16: ret: 0x000003ca, entry: 0x000003c9, offset: 0x03c9
>> FAT16: entry: 0x000003ca = 970, offset: 0x03ca = 970
>> FAT16: ret: 0x000003cb, entry: 0x000003ca, offset: 0x03ca
>> FAT16: entry: 0x000003cb = 971, offset: 0x03cb = 971
>> FAT16: ret: 0x000003cc, entry: 0x000003cb, offset: 0x03cb
>> FAT16: entry: 0x000003cc = 972, offset: 0x03cc = 972
>> FAT16: ret: 0x000003cd, entry: 0x000003cc, offset: 0x03cc
>> FAT16: entry: 0x000003cd = 973, offset: 0x03cd = 973
>> FAT16: ret: 0x000003ce, entry: 0x000003cd, offset: 0x03cd
>> FAT16: entry: 0x000003ce = 974, offset: 0x03ce = 974
>> FAT16: ret: 0x000003cf, entry: 0x000003ce, offset: 0x03ce
>> FAT16: entry: 0x000003cf = 975, offset: 0x03cf = 975
>> FAT16: ret: 0x000003d0, entry: 0x000003cf, offset: 0x03cf
>> FAT16: entry: 0x000003d0 = 976, offset: 0x03d0 = 976
>> FAT16: ret: 0x000003d1, entry: 0x000003d0, offset: 0x03d0
>> FAT16: entry: 0x000003d1 = 977, offset: 0x03d1 = 977
>> FAT16: ret: 0x000003d2, entry: 0x000003d1, offset: 0x03d1
>> FAT16: entry: 0x000003d2 = 978, offset: 0x03d2 = 978
>> FAT16: ret: 0x000003d3, entry: 0x000003d2, offset: 0x03d2
>> FAT16: entry: 0x000003d3 = 979, offset: 0x03d3 = 979
>> FAT16: ret: 0x000003d4, entry: 0x000003d3, offset: 0x03d3
>> FAT16: entry: 0x000003d4 = 980, offset: 0x03d4 = 980
>> FAT16: ret: 0x000003d5, entry: 0x000003d4, offset: 0x03d4
>> FAT16: entry: 0x000003d5 = 981, offset: 0x03d5 = 981
>> FAT16: ret: 0x000003d6, entry: 0x000003d5, offset: 0x03d5
>> FAT16: entry: 0x000003d6 = 982, offset: 0x03d6 = 982
>> FAT16: ret: 0x000003d7, entry: 0x000003d6, offset: 0x03d6
>> FAT16: entry: 0x000003d7 = 983, offset: 0x03d7 = 983
>> FAT16: ret: 0x000003d8, entry: 0x000003d7, offset: 0x03d7
>> FAT16: entry: 0x000003d8 = 984, offset: 0x03d8 = 984
>> FAT16: ret: 0x000003d9, entry: 0x000003d8, offset: 0x03d8
>> FAT16: entry: 0x000003d9 = 985, offset: 0x03d9 = 985
>> FAT16: ret: 0x000003da, entry: 0x000003d9, offset: 0x03d9
>> FAT16: entry: 0x000003da = 986, offset: 0x03da = 986
>> FAT16: ret: 0x000003db, entry: 0x000003da, offset: 0x03da
>> FAT16: entry: 0x000003db = 987, offset: 0x03db = 987
>> FAT16: ret: 0x000003dc, entry: 0x000003db, offset: 0x03db
>> FAT16: entry: 0x000003dc = 988, offset: 0x03dc = 988
>> FAT16: ret: 0x000003dd, entry: 0x000003dc, offset: 0x03dc
>> FAT16: entry: 0x000003dd = 989, offset: 0x03dd = 989
>> FAT16: ret: 0x000003de, entry: 0x000003dd, offset: 0x03dd
>> FAT16: entry: 0x000003de = 990, offset: 0x03de = 990
>> FAT16: ret: 0x000003df, entry: 0x000003de, offset: 0x03de
>> FAT16: entry: 0x000003df = 991, offset: 0x03df = 991
>> FAT16: ret: 0x000003e0, entry: 0x000003df, offset: 0x03df
>> FAT16: entry: 0x000003e0 = 992, offset: 0x03e0 = 992
>> FAT16: ret: 0x000003e1, entry: 0x000003e0, offset: 0x03e0
>> FAT16: entry: 0x000003e1 = 993, offset: 0x03e1 = 993
>> FAT16: ret: 0x000003e2, entry: 0x000003e1, offset: 0x03e1
>> FAT16: entry: 0x000003e2 = 994, offset: 0x03e2 = 994
>> FAT16: ret: 0x000003e3, entry: 0x000003e2, offset: 0x03e2
>> FAT16: entry: 0x000003e3 = 995, offset: 0x03e3 = 995
>> FAT16: ret: 0x000003e4, entry: 0x000003e3, offset: 0x03e3
>> FAT16: entry: 0x000003e4 = 996, offset: 0x03e4 = 996
>> FAT16: ret: 0x000003e5, entry: 0x000003e4, offset: 0x03e4
>> FAT16: entry: 0x000003e5 = 997, offset: 0x03e5 = 997
>> FAT16: ret: 0x000003e6, entry: 0x000003e5, offset: 0x03e5
>> FAT16: entry: 0x000003e6 = 998, offset: 0x03e6 = 998
>> FAT16: ret: 0x000003e7, entry: 0x000003e6, offset: 0x03e6
>> FAT16: entry: 0x000003e7 = 999, offset: 0x03e7 = 999
>> FAT16: ret: 0x000003e8, entry: 0x000003e7, offset: 0x03e7
>> FAT16: entry: 0x000003e8 = 1000, offset: 0x03e8 = 1000
>> FAT16: ret: 0x000003e9, entry: 0x000003e8, offset: 0x03e8
>> FAT16: entry: 0x000003e9 = 1001, offset: 0x03e9 = 1001
>> FAT16: ret: 0x000003ea, entry: 0x000003e9, offset: 0x03e9
>> FAT16: entry: 0x000003ea = 1002, offset: 0x03ea = 1002
>> FAT16: ret: 0x000003eb, entry: 0x000003ea, offset: 0x03ea
>> FAT16: entry: 0x000003eb = 1003, offset: 0x03eb = 1003
>> FAT16: ret: 0x000003ec, entry: 0x000003eb, offset: 0x03eb
>> FAT16: entry: 0x000003ec = 1004, offset: 0x03ec = 1004
>> FAT16: ret: 0x000003ed, entry: 0x000003ec, offset: 0x03ec
>> FAT16: entry: 0x000003ed = 1005, offset: 0x03ed = 1005
>> FAT16: ret: 0x000003ee, entry: 0x000003ed, offset: 0x03ed
>> FAT16: entry: 0x000003ee = 1006, offset: 0x03ee = 1006
>> FAT16: ret: 0x000003ef, entry: 0x000003ee, offset: 0x03ee
>> FAT16: entry: 0x000003ef = 1007, offset: 0x03ef = 1007
>> FAT16: ret: 0x000003f0, entry: 0x000003ef, offset: 0x03ef
>> FAT16: entry: 0x000003f0 = 1008, offset: 0x03f0 = 1008
>> FAT16: ret: 0x000003f1, entry: 0x000003f0, offset: 0x03f0
>> FAT16: entry: 0x000003f1 = 1009, offset: 0x03f1 = 1009
>> FAT16: ret: 0x000003f2, entry: 0x000003f1, offset: 0x03f1
>> FAT16: entry: 0x000003f2 = 1010, offset: 0x03f2 = 1010
>> FAT16: ret: 0x000003f3, entry: 0x000003f2, offset: 0x03f2
>> FAT16: entry: 0x000003f3 = 1011, offset: 0x03f3 = 1011
>> FAT16: ret: 0x000003f4, entry: 0x000003f3, offset: 0x03f3
>> FAT16: entry: 0x000003f4 = 1012, offset: 0x03f4 = 1012
>> FAT16: ret: 0x000003f5, entry: 0x000003f4, offset: 0x03f4
>> FAT16: entry: 0x000003f5 = 1013, offset: 0x03f5 = 1013
>> FAT16: ret: 0x000003f6, entry: 0x000003f5, offset: 0x03f5
>> FAT16: entry: 0x000003f6 = 1014, offset: 0x03f6 = 1014
>> FAT16: ret: 0x000005f7, entry: 0x000003f6, offset: 0x03f6
>> FAT16: entry: 0x000005f7 = 1527, offset: 0x05f7 = 1527
>> FAT16: ret: 0x000005f8, entry: 0x000005f7, offset: 0x05f7
>> FAT16: entry: 0x000005f8 = 1528, offset: 0x05f8 = 1528
>> FAT16: ret: 0x000005f9, entry: 0x000005f8, offset: 0x05f8
>> FAT16: entry: 0x000005f9 = 1529, offset: 0x05f9 = 1529
>> FAT16: ret: 0x000005fa, entry: 0x000005f9, offset: 0x05f9
>> FAT16: entry: 0x000005fa = 1530, offset: 0x05fa = 1530
>> FAT16: ret: 0x000005fb, entry: 0x000005fa, offset: 0x05fa
>> FAT16: entry: 0x000005fb = 1531, offset: 0x05fb = 1531
>> FAT16: ret: 0x000005fc, entry: 0x000005fb, offset: 0x05fb
>> FAT16: entry: 0x000005fc = 1532, offset: 0x05fc = 1532
>> FAT16: ret: 0x000005fd, entry: 0x000005fc, offset: 0x05fc
>> FAT16: entry: 0x000005fd = 1533, offset: 0x05fd = 1533
>> FAT16: ret: 0x000005fe, entry: 0x000005fd, offset: 0x05fd
>> FAT16: entry: 0x000005fe = 1534, offset: 0x05fe = 1534
>> FAT16: ret: 0x000005ff, entry: 0x000005fe, offset: 0x05fe
>> FAT16: entry: 0x000005ff = 1535, offset: 0x05ff = 1535
>> FAT16: ret: 0x00000600, entry: 0x000005ff, offset: 0x05ff
>> FAT16: entry: 0x00000600 = 1536, offset: 0x0000 = 0
>> debug: evicting 0, dirty: 0
>> FAT16: ret: 0x00000601, entry: 0x00000600, offset: 0x0000
>> FAT16: entry: 0x00000601 = 1537, offset: 0x0001 = 1
>> FAT16: ret: 0x00000602, entry: 0x00000601, offset: 0x0001
>> FAT16: entry: 0x00000602 = 1538, offset: 0x0002 = 2
>> FAT16: ret: 0x00000603, entry: 0x00000602, offset: 0x0002
>> FAT16: entry: 0x00000603 = 1539, offset: 0x0003 = 3
>> FAT16: ret: 0x00000604, entry: 0x00000603, offset: 0x0003
>> FAT16: entry: 0x00000604 = 1540, offset: 0x0004 = 4
>> FAT16: ret: 0x00000605, entry: 0x00000604, offset: 0x0004
>> FAT16: entry: 0x00000605 = 1541, offset: 0x0005 = 5
>> FAT16: ret: 0x00000606, entry: 0x00000605, offset: 0x0005
>> FAT16: entry: 0x00000606 = 1542, offset: 0x0006 = 6
>> FAT16: ret: 0x00000607, entry: 0x00000606, offset: 0x0006
>> FAT16: entry: 0x00000607 = 1543, offset: 0x0007 = 7
>> FAT16: ret: 0x00000608, entry: 0x00000607, offset: 0x0007
>> FAT16: entry: 0x00000608 = 1544, offset: 0x0008 = 8
>> FAT16: ret: 0x00000609, entry: 0x00000608, offset: 0x0008
>> FAT16: entry: 0x00000609 = 1545, offset: 0x0009 = 9
>> FAT16: ret: 0x0000060a, entry: 0x00000609, offset: 0x0009
>> FAT16: entry: 0x0000060a = 1546, offset: 0x000a = 10
>> FAT16: ret: 0x0000060b, entry: 0x0000060a, offset: 0x000a
>> FAT16: entry: 0x0000060b = 1547, offset: 0x000b = 11
>> FAT16: ret: 0x0000060c, entry: 0x0000060b, offset: 0x000b
>> FAT16: entry: 0x0000060c = 1548, offset: 0x000c = 12
>> FAT16: ret: 0x0000060d, entry: 0x0000060c, offset: 0x000c
>> FAT16: entry: 0x0000060d = 1549, offset: 0x000d = 13
>> FAT16: ret: 0x0000060e, entry: 0x0000060d, offset: 0x000d
>> FAT16: entry: 0x0000060e = 1550, offset: 0x000e = 14
>> FAT16: ret: 0x0000060f, entry: 0x0000060e, offset: 0x000e
>> FAT16: entry: 0x0000060f = 1551, offset: 0x000f = 15
>> FAT16: ret: 0x00000610, entry: 0x0000060f, offset: 0x000f
>> FAT16: entry: 0x00000610 = 1552, offset: 0x0010 = 16
>> FAT16: ret: 0x00000611, entry: 0x00000610, offset: 0x0010
>> FAT16: entry: 0x00000611 = 1553, offset: 0x0011 = 17
>> FAT16: ret: 0x00000612, entry: 0x00000611, offset: 0x0011
>> FAT16: entry: 0x00000612 = 1554, offset: 0x0012 = 18
>> FAT16: ret: 0x00000613, entry: 0x00000612, offset: 0x0012
>> FAT16: entry: 0x00000613 = 1555, offset: 0x0013 = 19
>> FAT16: ret: 0x00000614, entry: 0x00000613, offset: 0x0013
>> FAT16: entry: 0x00000614 = 1556, offset: 0x0014 = 20
>> FAT16: ret: 0x00000615, entry: 0x00000614, offset: 0x0014
>> FAT16: entry: 0x00000615 = 1557, offset: 0x0015 = 21
>> FAT16: ret: 0x00000616, entry: 0x00000615, offset: 0x0015
>> FAT16: entry: 0x00000616 = 1558, offset: 0x0016 = 22
>> FAT16: ret: 0x00000617, entry: 0x00000616, offset: 0x0016
>> FAT16: entry: 0x00000617 = 1559, offset: 0x0017 = 23
>> FAT16: ret: 0x00000618, entry: 0x00000617, offset: 0x0017
>> FAT16: entry: 0x00000618 = 1560, offset: 0x0018 = 24
>> FAT16: ret: 0x00000619, entry: 0x00000618, offset: 0x0018
>> FAT16: entry: 0x00000619 = 1561, offset: 0x0019 = 25
>> FAT16: ret: 0x0000061a, entry: 0x00000619, offset: 0x0019
>> FAT16: entry: 0x0000061a = 1562, offset: 0x001a = 26
>> FAT16: ret: 0x0000061b, entry: 0x0000061a, offset: 0x001a
>> FAT16: entry: 0x0000061b = 1563, offset: 0x001b = 27
>> FAT16: ret: 0x0000061c, entry: 0x0000061b, offset: 0x001b
>> FAT16: entry: 0x0000061c = 1564, offset: 0x001c = 28
>> FAT16: ret: 0x0000061d, entry: 0x0000061c, offset: 0x001c
>> FAT16: entry: 0x0000061d = 1565, offset: 0x001d = 29
>> FAT16: ret: 0x0000061e, entry: 0x0000061d, offset: 0x001d
>> FAT16: entry: 0x0000061e = 1566, offset: 0x001e = 30
>> FAT16: ret: 0x0000061f, entry: 0x0000061e, offset: 0x001e
>> FAT16: entry: 0x0000061f = 1567, offset: 0x001f = 31
>> FAT16: ret: 0x00000620, entry: 0x0000061f, offset: 0x001f
>> FAT16: entry: 0x00000620 = 1568, offset: 0x0020 = 32
>> FAT16: ret: 0x00000621, entry: 0x00000620, offset: 0x0020
>> FAT16: entry: 0x00000621 = 1569, offset: 0x0021 = 33
>> FAT16: ret: 0x00000622, entry: 0x00000621, offset: 0x0021
>> FAT16: entry: 0x00000622 = 1570, offset: 0x0022 = 34
>> FAT16: ret: 0x00000623, entry: 0x00000622, offset: 0x0022
>> FAT16: entry: 0x00000623 = 1571, offset: 0x0023 = 35
>> FAT16: ret: 0x00000624, entry: 0x00000623, offset: 0x0023
>> FAT16: entry: 0x00000624 = 1572, offset: 0x0024 = 36
>> FAT16: ret: 0x00000625, entry: 0x00000624, offset: 0x0024
>> FAT16: entry: 0x00000625 = 1573, offset: 0x0025 = 37
>> FAT16: ret: 0x00000626, entry: 0x00000625, offset: 0x0025
>> FAT16: entry: 0x00000626 = 1574, offset: 0x0026 = 38
>> FAT16: ret: 0x00000627, entry: 0x00000626, offset: 0x0026
>> FAT16: entry: 0x00000627 = 1575, offset: 0x0027 = 39
>> FAT16: ret: 0x00000628, entry: 0x00000627, offset: 0x0027
>> FAT16: entry: 0x00000628 = 1576, offset: 0x0028 = 40
>> FAT16: ret: 0x00000629, entry: 0x00000628, offset: 0x0028
>> FAT16: entry: 0x00000629 = 1577, offset: 0x0029 = 41
>> FAT16: ret: 0x0000062a, entry: 0x00000629, offset: 0x0029
>> FAT16: entry: 0x0000062a = 1578, offset: 0x002a = 42
>> FAT16: ret: 0x0000062b, entry: 0x0000062a, offset: 0x002a
>> FAT16: entry: 0x0000062b = 1579, offset: 0x002b = 43
>> FAT16: ret: 0x0000062c, entry: 0x0000062b, offset: 0x002b
>> clustnum: 525, startsect: 2525, pos: 0
>> FAT16: entry: 0x0000062c = 1580, offset: 0x002c = 44
>> FAT16: ret: 0x0000ffff, entry: 0x0000062c, offset: 0x002c
>> attempt to write 0x100000 bytes
>> debug: evicting 1, dirty: 0
>> clustnum: -6, startsect: 401
>> 1048576 bytes written
>> switch to partitions #0, OK
>> mmc1(part 0) is current device
>> switch to partitions #0, OK
>> mmc0 is current device
>> READING!
>> FAT16, fat_sect: 1, fatlength: 200
>> Rootdir begins at cluster: -6, sector: 401, offset: 32200
>> Data begins at: 425
>> Sector size: 512, cluster size: 4
>> FAT read(sect=401), clust_size=4, DIRENTSPERBLOCK=16
>> reading u-boot.img at pos 0
>> Filesize: 1048576 bytes
>> 1048576 bytes
>> FAT16: entry: 0x0000020d = 525, offset: 0x020d = 525
>> debug: evicting -1, dirty: 0
>> FAT16: ret: 0x0000020e, entry: 0x0000020d, offset: 0x020d
>> FAT16: entry: 0x0000020e = 526, offset: 0x020e = 526
>> FAT16: ret: 0x0000020f, entry: 0x0000020e, offset: 0x020e
>> FAT16: entry: 0x0000020f = 527, offset: 0x020f = 527
>> FAT16: ret: 0x00000210, entry: 0x0000020f, offset: 0x020f
>> FAT16: entry: 0x00000210 = 528, offset: 0x0210 = 528
>> FAT16: ret: 0x00000211, entry: 0x00000210, offset: 0x0210
>> FAT16: entry: 0x00000211 = 529, offset: 0x0211 = 529
>> FAT16: ret: 0x00000212, entry: 0x00000211, offset: 0x0211
>> FAT16: entry: 0x00000212 = 530, offset: 0x0212 = 530
>> FAT16: ret: 0x00000213, entry: 0x00000212, offset: 0x0212
>> FAT16: entry: 0x00000213 = 531, offset: 0x0213 = 531
>> FAT16: ret: 0x00000214, entry: 0x00000213, offset: 0x0213
>> FAT16: entry: 0x00000214 = 532, offset: 0x0214 = 532
>> FAT16: ret: 0x00000215, entry: 0x00000214, offset: 0x0214
>> FAT16: entry: 0x00000215 = 533, offset: 0x0215 = 533
>> FAT16: ret: 0x00000216, entry: 0x00000215, offset: 0x0215
>> FAT16: entry: 0x00000216 = 534, offset: 0x0216 = 534
>> FAT16: ret: 0x00000217, entry: 0x00000216, offset: 0x0216
>> FAT16: entry: 0x00000217 = 535, offset: 0x0217 = 535
>> FAT16: ret: 0x00000218, entry: 0x00000217, offset: 0x0217
>> FAT16: entry: 0x00000218 = 536, offset: 0x0218 = 536
>> FAT16: ret: 0x00000219, entry: 0x00000218, offset: 0x0218
>> FAT16: entry: 0x00000219 = 537, offset: 0x0219 = 537
>> FAT16: ret: 0x0000021a, entry: 0x00000219, offset: 0x0219
>> FAT16: entry: 0x0000021a = 538, offset: 0x021a = 538
>> FAT16: ret: 0x0000021b, entry: 0x0000021a, offset: 0x021a
>> FAT16: entry: 0x0000021b = 539, offset: 0x021b = 539
>> FAT16: ret: 0x0000021c, entry: 0x0000021b, offset: 0x021b
>> FAT16: entry: 0x0000021c = 540, offset: 0x021c = 540
>> FAT16: ret: 0x0000021d, entry: 0x0000021c, offset: 0x021c
>> FAT16: entry: 0x0000021d = 541, offset: 0x021d = 541
>> FAT16: ret: 0x0000021e, entry: 0x0000021d, offset: 0x021d
>> FAT16: entry: 0x0000021e = 542, offset: 0x021e = 542
>> FAT16: ret: 0x0000021f, entry: 0x0000021e, offset: 0x021e
>> FAT16: entry: 0x0000021f = 543, offset: 0x021f = 543
>> FAT16: ret: 0x00000220, entry: 0x0000021f, offset: 0x021f
>> FAT16: entry: 0x00000220 = 544, offset: 0x0220 = 544
>> FAT16: ret: 0x00000221, entry: 0x00000220, offset: 0x0220
>> FAT16: entry: 0x00000221 = 545, offset: 0x0221 = 545
>> FAT16: ret: 0x00000222, entry: 0x00000221, offset: 0x0221
>> FAT16: entry: 0x00000222 = 546, offset: 0x0222 = 546
>> FAT16: ret: 0x00000223, entry: 0x00000222, offset: 0x0222
>> FAT16: entry: 0x00000223 = 547, offset: 0x0223 = 547
>> FAT16: ret: 0x00000224, entry: 0x00000223, offset: 0x0223
>> FAT16: entry: 0x00000224 = 548, offset: 0x0224 = 548
>> FAT16: ret: 0x00000225, entry: 0x00000224, offset: 0x0224
>> FAT16: entry: 0x00000225 = 549, offset: 0x0225 = 549
>> FAT16: ret: 0x00000226, entry: 0x00000225, offset: 0x0225
>> FAT16: entry: 0x00000226 = 550, offset: 0x0226 = 550
>> FAT16: ret: 0x00000227, entry: 0x00000226, offset: 0x0226
>> FAT16: entry: 0x00000227 = 551, offset: 0x0227 = 551
>> FAT16: ret: 0x00000228, entry: 0x00000227, offset: 0x0227
>> FAT16: entry: 0x00000228 = 552, offset: 0x0228 = 552
>> FAT16: ret: 0x00000229, entry: 0x00000228, offset: 0x0228
>> FAT16: entry: 0x00000229 = 553, offset: 0x0229 = 553
>> FAT16: ret: 0x0000022a, entry: 0x00000229, offset: 0x0229
>> FAT16: entry: 0x0000022a = 554, offset: 0x022a = 554
>> FAT16: ret: 0x0000022b, entry: 0x0000022a, offset: 0x022a
>> FAT16: entry: 0x0000022b = 555, offset: 0x022b = 555
>> FAT16: ret: 0x0000022c, entry: 0x0000022b, offset: 0x022b
>> FAT16: entry: 0x0000022c = 556, offset: 0x022c = 556
>> FAT16: ret: 0x0000022d, entry: 0x0000022c, offset: 0x022c
>> FAT16: entry: 0x0000022d = 557, offset: 0x022d = 557
>> FAT16: ret: 0x0000022e, entry: 0x0000022d, offset: 0x022d
>> FAT16: entry: 0x0000022e = 558, offset: 0x022e = 558
>> FAT16: ret: 0x0000022f, entry: 0x0000022e, offset: 0x022e
>> FAT16: entry: 0x0000022f = 559, offset: 0x022f = 559
>> FAT16: ret: 0x00000230, entry: 0x0000022f, offset: 0x022f
>> FAT16: entry: 0x00000230 = 560, offset: 0x0230 = 560
>> FAT16: ret: 0x00000231, entry: 0x00000230, offset: 0x0230
>> FAT16: entry: 0x00000231 = 561, offset: 0x0231 = 561
>> FAT16: ret: 0x00000232, entry: 0x00000231, offset: 0x0231
>> FAT16: entry: 0x00000232 = 562, offset: 0x0232 = 562
>> FAT16: ret: 0x00000233, entry: 0x00000232, offset: 0x0232
>> FAT16: entry: 0x00000233 = 563, offset: 0x0233 = 563
>> FAT16: ret: 0x00000234, entry: 0x00000233, offset: 0x0233
>> FAT16: entry: 0x00000234 = 564, offset: 0x0234 = 564
>> FAT16: ret: 0x00000235, entry: 0x00000234, offset: 0x0234
>> FAT16: entry: 0x00000235 = 565, offset: 0x0235 = 565
>> FAT16: ret: 0x00000236, entry: 0x00000235, offset: 0x0235
>> FAT16: entry: 0x00000236 = 566, offset: 0x0236 = 566
>> FAT16: ret: 0x00000237, entry: 0x00000236, offset: 0x0236
>> FAT16: entry: 0x00000237 = 567, offset: 0x0237 = 567
>> FAT16: ret: 0x00000238, entry: 0x00000237, offset: 0x0237
>> FAT16: entry: 0x00000238 = 568, offset: 0x0238 = 568
>> FAT16: ret: 0x00000239, entry: 0x00000238, offset: 0x0238
>> FAT16: entry: 0x00000239 = 569, offset: 0x0239 = 569
>> FAT16: ret: 0x0000023a, entry: 0x00000239, offset: 0x0239
>> FAT16: entry: 0x0000023a = 570, offset: 0x023a = 570
>> FAT16: ret: 0x0000023b, entry: 0x0000023a, offset: 0x023a
>> FAT16: entry: 0x0000023b = 571, offset: 0x023b = 571
>> FAT16: ret: 0x0000023c, entry: 0x0000023b, offset: 0x023b
>> FAT16: entry: 0x0000023c = 572, offset: 0x023c = 572
>> FAT16: ret: 0x0000023d, entry: 0x0000023c, offset: 0x023c
>> FAT16: entry: 0x0000023d = 573, offset: 0x023d = 573
>> FAT16: ret: 0x0000023e, entry: 0x0000023d, offset: 0x023d
>> FAT16: entry: 0x0000023e = 574, offset: 0x023e = 574
>> FAT16: ret: 0x0000023f, entry: 0x0000023e, offset: 0x023e
>> FAT16: entry: 0x0000023f = 575, offset: 0x023f = 575
>> FAT16: ret: 0x00000240, entry: 0x0000023f, offset: 0x023f
>> FAT16: entry: 0x00000240 = 576, offset: 0x0240 = 576
>> FAT16: ret: 0x00000241, entry: 0x00000240, offset: 0x0240
>> FAT16: entry: 0x00000241 = 577, offset: 0x0241 = 577
>> FAT16: ret: 0x00000242, entry: 0x00000241, offset: 0x0241
>> FAT16: entry: 0x00000242 = 578, offset: 0x0242 = 578
>> FAT16: ret: 0x00000243, entry: 0x00000242, offset: 0x0242
>> FAT16: entry: 0x00000243 = 579, offset: 0x0243 = 579
>> FAT16: ret: 0x00000244, entry: 0x00000243, offset: 0x0243
>> FAT16: entry: 0x00000244 = 580, offset: 0x0244 = 580
>> FAT16: ret: 0x00000245, entry: 0x00000244, offset: 0x0244
>> FAT16: entry: 0x00000245 = 581, offset: 0x0245 = 581
>> FAT16: ret: 0x00000246, entry: 0x00000245, offset: 0x0245
>> FAT16: entry: 0x00000246 = 582, offset: 0x0246 = 582
>> FAT16: ret: 0x00000247, entry: 0x00000246, offset: 0x0246
>> FAT16: entry: 0x00000247 = 583, offset: 0x0247 = 583
>> FAT16: ret: 0x00000248, entry: 0x00000247, offset: 0x0247
>> FAT16: entry: 0x00000248 = 584, offset: 0x0248 = 584
>> FAT16: ret: 0x00000249, entry: 0x00000248, offset: 0x0248
>> FAT16: entry: 0x00000249 = 585, offset: 0x0249 = 585
>> FAT16: ret: 0x0000024a, entry: 0x00000249, offset: 0x0249
>> FAT16: entry: 0x0000024a = 586, offset: 0x024a = 586
>> FAT16: ret: 0x0000024b, entry: 0x0000024a, offset: 0x024a
>> FAT16: entry: 0x0000024b = 587, offset: 0x024b = 587
>> FAT16: ret: 0x0000024c, entry: 0x0000024b, offset: 0x024b
>> FAT16: entry: 0x0000024c = 588, offset: 0x024c = 588
>> FAT16: ret: 0x0000024d, entry: 0x0000024c, offset: 0x024c
>> FAT16: entry: 0x0000024d = 589, offset: 0x024d = 589
>> FAT16: ret: 0x0000024e, entry: 0x0000024d, offset: 0x024d
>> FAT16: entry: 0x0000024e = 590, offset: 0x024e = 590
>> FAT16: ret: 0x0000024f, entry: 0x0000024e, offset: 0x024e
>> FAT16: entry: 0x0000024f = 591, offset: 0x024f = 591
>> FAT16: ret: 0x00000250, entry: 0x0000024f, offset: 0x024f
>> FAT16: entry: 0x00000250 = 592, offset: 0x0250 = 592
>> FAT16: ret: 0x00000251, entry: 0x00000250, offset: 0x0250
>> FAT16: entry: 0x00000251 = 593, offset: 0x0251 = 593
>> FAT16: ret: 0x00000252, entry: 0x00000251, offset: 0x0251
>> FAT16: entry: 0x00000252 = 594, offset: 0x0252 = 594
>> FAT16: ret: 0x00000253, entry: 0x00000252, offset: 0x0252
>> FAT16: entry: 0x00000253 = 595, offset: 0x0253 = 595
>> FAT16: ret: 0x00000254, entry: 0x00000253, offset: 0x0253
>> FAT16: entry: 0x00000254 = 596, offset: 0x0254 = 596
>> FAT16: ret: 0x00000255, entry: 0x00000254, offset: 0x0254
>> FAT16: entry: 0x00000255 = 597, offset: 0x0255 = 597
>> FAT16: ret: 0x00000256, entry: 0x00000255, offset: 0x0255
>> FAT16: entry: 0x00000256 = 598, offset: 0x0256 = 598
>> FAT16: ret: 0x00000257, entry: 0x00000256, offset: 0x0256
>> FAT16: entry: 0x00000257 = 599, offset: 0x0257 = 599
>> FAT16: ret: 0x00000258, entry: 0x00000257, offset: 0x0257
>> FAT16: entry: 0x00000258 = 600, offset: 0x0258 = 600
>> FAT16: ret: 0x00000259, entry: 0x00000258, offset: 0x0258
>> FAT16: entry: 0x00000259 = 601, offset: 0x0259 = 601
>> FAT16: ret: 0x0000025a, entry: 0x00000259, offset: 0x0259
>> FAT16: entry: 0x0000025a = 602, offset: 0x025a = 602
>> FAT16: ret: 0x0000025b, entry: 0x0000025a, offset: 0x025a
>> FAT16: entry: 0x0000025b = 603, offset: 0x025b = 603
>> FAT16: ret: 0x0000025c, entry: 0x0000025b, offset: 0x025b
>> FAT16: entry: 0x0000025c = 604, offset: 0x025c = 604
>> FAT16: ret: 0x0000025d, entry: 0x0000025c, offset: 0x025c
>> FAT16: entry: 0x0000025d = 605, offset: 0x025d = 605
>> FAT16: ret: 0x0000025e, entry: 0x0000025d, offset: 0x025d
>> FAT16: entry: 0x0000025e = 606, offset: 0x025e = 606
>> FAT16: ret: 0x0000025f, entry: 0x0000025e, offset: 0x025e
>> FAT16: entry: 0x0000025f = 607, offset: 0x025f = 607
>> FAT16: ret: 0x00000260, entry: 0x0000025f, offset: 0x025f
>> FAT16: entry: 0x00000260 = 608, offset: 0x0260 = 608
>> FAT16: ret: 0x00000261, entry: 0x00000260, offset: 0x0260
>> FAT16: entry: 0x00000261 = 609, offset: 0x0261 = 609
>> FAT16: ret: 0x00000262, entry: 0x00000261, offset: 0x0261
>> FAT16: entry: 0x00000262 = 610, offset: 0x0262 = 610
>> FAT16: ret: 0x00000263, entry: 0x00000262, offset: 0x0262
>> FAT16: entry: 0x00000263 = 611, offset: 0x0263 = 611
>> FAT16: ret: 0x00000264, entry: 0x00000263, offset: 0x0263
>> FAT16: entry: 0x00000264 = 612, offset: 0x0264 = 612
>> FAT16: ret: 0x00000265, entry: 0x00000264, offset: 0x0264
>> FAT16: entry: 0x00000265 = 613, offset: 0x0265 = 613
>> FAT16: ret: 0x00000266, entry: 0x00000265, offset: 0x0265
>> FAT16: entry: 0x00000266 = 614, offset: 0x0266 = 614
>> FAT16: ret: 0x00000267, entry: 0x00000266, offset: 0x0266
>> FAT16: entry: 0x00000267 = 615, offset: 0x0267 = 615
>> FAT16: ret: 0x00000268, entry: 0x00000267, offset: 0x0267
>> FAT16: entry: 0x00000268 = 616, offset: 0x0268 = 616
>> FAT16: ret: 0x00000269, entry: 0x00000268, offset: 0x0268
>> FAT16: entry: 0x00000269 = 617, offset: 0x0269 = 617
>> FAT16: ret: 0x0000026a, entry: 0x00000269, offset: 0x0269
>> FAT16: entry: 0x0000026a = 618, offset: 0x026a = 618
>> FAT16: ret: 0x0000026b, entry: 0x0000026a, offset: 0x026a
>> FAT16: entry: 0x0000026b = 619, offset: 0x026b = 619
>> FAT16: ret: 0x0000026c, entry: 0x0000026b, offset: 0x026b
>> FAT16: entry: 0x0000026c = 620, offset: 0x026c = 620
>> FAT16: ret: 0x0000026d, entry: 0x0000026c, offset: 0x026c
>> FAT16: entry: 0x0000026d = 621, offset: 0x026d = 621
>> FAT16: ret: 0x0000026e, entry: 0x0000026d, offset: 0x026d
>> FAT16: entry: 0x0000026e = 622, offset: 0x026e = 622
>> FAT16: ret: 0x0000026f, entry: 0x0000026e, offset: 0x026e
>> FAT16: entry: 0x0000026f = 623, offset: 0x026f = 623
>> FAT16: ret: 0x00000270, entry: 0x0000026f, offset: 0x026f
>> FAT16: entry: 0x00000270 = 624, offset: 0x0270 = 624
>> FAT16: ret: 0x00000271, entry: 0x00000270, offset: 0x0270
>> FAT16: entry: 0x00000271 = 625, offset: 0x0271 = 625
>> FAT16: ret: 0x00000272, entry: 0x00000271, offset: 0x0271
>> FAT16: entry: 0x00000272 = 626, offset: 0x0272 = 626
>> FAT16: ret: 0x00000273, entry: 0x00000272, offset: 0x0272
>> FAT16: entry: 0x00000273 = 627, offset: 0x0273 = 627
>> FAT16: ret: 0x00000274, entry: 0x00000273, offset: 0x0273
>> FAT16: entry: 0x00000274 = 628, offset: 0x0274 = 628
>> FAT16: ret: 0x00000275, entry: 0x00000274, offset: 0x0274
>> FAT16: entry: 0x00000275 = 629, offset: 0x0275 = 629
>> FAT16: ret: 0x00000276, entry: 0x00000275, offset: 0x0275
>> FAT16: entry: 0x00000276 = 630, offset: 0x0276 = 630
>> FAT16: ret: 0x00000277, entry: 0x00000276, offset: 0x0276
>> FAT16: entry: 0x00000277 = 631, offset: 0x0277 = 631
>> FAT16: ret: 0x00000278, entry: 0x00000277, offset: 0x0277
>> FAT16: entry: 0x00000278 = 632, offset: 0x0278 = 632
>> FAT16: ret: 0x00000279, entry: 0x00000278, offset: 0x0278
>> FAT16: entry: 0x00000279 = 633, offset: 0x0279 = 633
>> FAT16: ret: 0x0000027a, entry: 0x00000279, offset: 0x0279
>> FAT16: entry: 0x0000027a = 634, offset: 0x027a = 634
>> FAT16: ret: 0x0000027b, entry: 0x0000027a, offset: 0x027a
>> FAT16: entry: 0x0000027b = 635, offset: 0x027b = 635
>> FAT16: ret: 0x0000027c, entry: 0x0000027b, offset: 0x027b
>> FAT16: entry: 0x0000027c = 636, offset: 0x027c = 636
>> FAT16: ret: 0x0000027d, entry: 0x0000027c, offset: 0x027c
>> FAT16: entry: 0x0000027d = 637, offset: 0x027d = 637
>> FAT16: ret: 0x0000027e, entry: 0x0000027d, offset: 0x027d
>> FAT16: entry: 0x0000027e = 638, offset: 0x027e = 638
>> FAT16: ret: 0x0000027f, entry: 0x0000027e, offset: 0x027e
>> FAT16: entry: 0x0000027f = 639, offset: 0x027f = 639
>> FAT16: ret: 0x00000280, entry: 0x0000027f, offset: 0x027f
>> FAT16: entry: 0x00000280 = 640, offset: 0x0280 = 640
>> FAT16: ret: 0x00000281, entry: 0x00000280, offset: 0x0280
>> FAT16: entry: 0x00000281 = 641, offset: 0x0281 = 641
>> FAT16: ret: 0x00000282, entry: 0x00000281, offset: 0x0281
>> FAT16: entry: 0x00000282 = 642, offset: 0x0282 = 642
>> FAT16: ret: 0x00000283, entry: 0x00000282, offset: 0x0282
>> FAT16: entry: 0x00000283 = 643, offset: 0x0283 = 643
>> FAT16: ret: 0x00000284, entry: 0x00000283, offset: 0x0283
>> FAT16: entry: 0x00000284 = 644, offset: 0x0284 = 644
>> FAT16: ret: 0x00000285, entry: 0x00000284, offset: 0x0284
>> FAT16: entry: 0x00000285 = 645, offset: 0x0285 = 645
>> FAT16: ret: 0x00000286, entry: 0x00000285, offset: 0x0285
>> FAT16: entry: 0x00000286 = 646, offset: 0x0286 = 646
>> FAT16: ret: 0x00000287, entry: 0x00000286, offset: 0x0286
>> FAT16: entry: 0x00000287 = 647, offset: 0x0287 = 647
>> FAT16: ret: 0x00000288, entry: 0x00000287, offset: 0x0287
>> FAT16: entry: 0x00000288 = 648, offset: 0x0288 = 648
>> FAT16: ret: 0x00000289, entry: 0x00000288, offset: 0x0288
>> FAT16: entry: 0x00000289 = 649, offset: 0x0289 = 649
>> FAT16: ret: 0x0000028a, entry: 0x00000289, offset: 0x0289
>> FAT16: entry: 0x0000028a = 650, offset: 0x028a = 650
>> FAT16: ret: 0x0000028b, entry: 0x0000028a, offset: 0x028a
>> FAT16: entry: 0x0000028b = 651, offset: 0x028b = 651
>> FAT16: ret: 0x0000028c, entry: 0x0000028b, offset: 0x028b
>> FAT16: entry: 0x0000028c = 652, offset: 0x028c = 652
>> FAT16: ret: 0x0000028d, entry: 0x0000028c, offset: 0x028c
>> FAT16: entry: 0x0000028d = 653, offset: 0x028d = 653
>> FAT16: ret: 0x0000028e, entry: 0x0000028d, offset: 0x028d
>> FAT16: entry: 0x0000028e = 654, offset: 0x028e = 654
>> FAT16: ret: 0x0000028f, entry: 0x0000028e, offset: 0x028e
>> FAT16: entry: 0x0000028f = 655, offset: 0x028f = 655
>> FAT16: ret: 0x00000290, entry: 0x0000028f, offset: 0x028f
>> FAT16: entry: 0x00000290 = 656, offset: 0x0290 = 656
>> FAT16: ret: 0x00000291, entry: 0x00000290, offset: 0x0290
>> FAT16: entry: 0x00000291 = 657, offset: 0x0291 = 657
>> FAT16: ret: 0x00000292, entry: 0x00000291, offset: 0x0291
>> FAT16: entry: 0x00000292 = 658, offset: 0x0292 = 658
>> FAT16: ret: 0x00000293, entry: 0x00000292, offset: 0x0292
>> FAT16: entry: 0x00000293 = 659, offset: 0x0293 = 659
>> FAT16: ret: 0x00000294, entry: 0x00000293, offset: 0x0293
>> FAT16: entry: 0x00000294 = 660, offset: 0x0294 = 660
>> FAT16: ret: 0x00000295, entry: 0x00000294, offset: 0x0294
>> FAT16: entry: 0x00000295 = 661, offset: 0x0295 = 661
>> FAT16: ret: 0x00000296, entry: 0x00000295, offset: 0x0295
>> FAT16: entry: 0x00000296 = 662, offset: 0x0296 = 662
>> FAT16: ret: 0x00000297, entry: 0x00000296, offset: 0x0296
>> FAT16: entry: 0x00000297 = 663, offset: 0x0297 = 663
>> FAT16: ret: 0x00000298, entry: 0x00000297, offset: 0x0297
>> FAT16: entry: 0x00000298 = 664, offset: 0x0298 = 664
>> FAT16: ret: 0x00000299, entry: 0x00000298, offset: 0x0298
>> FAT16: entry: 0x00000299 = 665, offset: 0x0299 = 665
>> FAT16: ret: 0x0000029a, entry: 0x00000299, offset: 0x0299
>> FAT16: entry: 0x0000029a = 666, offset: 0x029a = 666
>> FAT16: ret: 0x0000029b, entry: 0x0000029a, offset: 0x029a
>> FAT16: entry: 0x0000029b = 667, offset: 0x029b = 667
>> FAT16: ret: 0x0000029c, entry: 0x0000029b, offset: 0x029b
>> FAT16: entry: 0x0000029c = 668, offset: 0x029c = 668
>> FAT16: ret: 0x0000029d, entry: 0x0000029c, offset: 0x029c
>> FAT16: entry: 0x0000029d = 669, offset: 0x029d = 669
>> FAT16: ret: 0x0000029e, entry: 0x0000029d, offset: 0x029d
>> FAT16: entry: 0x0000029e = 670, offset: 0x029e = 670
>> FAT16: ret: 0x0000029f, entry: 0x0000029e, offset: 0x029e
>> FAT16: entry: 0x0000029f = 671, offset: 0x029f = 671
>> FAT16: ret: 0x000002a0, entry: 0x0000029f, offset: 0x029f
>> FAT16: entry: 0x000002a0 = 672, offset: 0x02a0 = 672
>> FAT16: ret: 0x000002a1, entry: 0x000002a0, offset: 0x02a0
>> FAT16: entry: 0x000002a1 = 673, offset: 0x02a1 = 673
>> FAT16: ret: 0x000002a2, entry: 0x000002a1, offset: 0x02a1
>> FAT16: entry: 0x000002a2 = 674, offset: 0x02a2 = 674
>> FAT16: ret: 0x000002a3, entry: 0x000002a2, offset: 0x02a2
>> FAT16: entry: 0x000002a3 = 675, offset: 0x02a3 = 675
>> FAT16: ret: 0x000002a4, entry: 0x000002a3, offset: 0x02a3
>> FAT16: entry: 0x000002a4 = 676, offset: 0x02a4 = 676
>> FAT16: ret: 0x000002a5, entry: 0x000002a4, offset: 0x02a4
>> FAT16: entry: 0x000002a5 = 677, offset: 0x02a5 = 677
>> FAT16: ret: 0x000002a6, entry: 0x000002a5, offset: 0x02a5
>> FAT16: entry: 0x000002a6 = 678, offset: 0x02a6 = 678
>> FAT16: ret: 0x000002a7, entry: 0x000002a6, offset: 0x02a6
>> FAT16: entry: 0x000002a7 = 679, offset: 0x02a7 = 679
>> FAT16: ret: 0x000002a8, entry: 0x000002a7, offset: 0x02a7
>> FAT16: entry: 0x000002a8 = 680, offset: 0x02a8 = 680
>> FAT16: ret: 0x000002a9, entry: 0x000002a8, offset: 0x02a8
>> FAT16: entry: 0x000002a9 = 681, offset: 0x02a9 = 681
>> FAT16: ret: 0x000002aa, entry: 0x000002a9, offset: 0x02a9
>> FAT16: entry: 0x000002aa = 682, offset: 0x02aa = 682
>> FAT16: ret: 0x000002ab, entry: 0x000002aa, offset: 0x02aa
>> FAT16: entry: 0x000002ab = 683, offset: 0x02ab = 683
>> FAT16: ret: 0x000002ac, entry: 0x000002ab, offset: 0x02ab
>> FAT16: entry: 0x000002ac = 684, offset: 0x02ac = 684
>> FAT16: ret: 0x000002ad, entry: 0x000002ac, offset: 0x02ac
>> FAT16: entry: 0x000002ad = 685, offset: 0x02ad = 685
>> FAT16: ret: 0x000002ae, entry: 0x000002ad, offset: 0x02ad
>> FAT16: entry: 0x000002ae = 686, offset: 0x02ae = 686
>> FAT16: ret: 0x000002af, entry: 0x000002ae, offset: 0x02ae
>> FAT16: entry: 0x000002af = 687, offset: 0x02af = 687
>> FAT16: ret: 0x000002b0, entry: 0x000002af, offset: 0x02af
>> FAT16: entry: 0x000002b0 = 688, offset: 0x02b0 = 688
>> FAT16: ret: 0x000002b1, entry: 0x000002b0, offset: 0x02b0
>> FAT16: entry: 0x000002b1 = 689, offset: 0x02b1 = 689
>> FAT16: ret: 0x000002b2, entry: 0x000002b1, offset: 0x02b1
>> FAT16: entry: 0x000002b2 = 690, offset: 0x02b2 = 690
>> FAT16: ret: 0x000002b3, entry: 0x000002b2, offset: 0x02b2
>> FAT16: entry: 0x000002b3 = 691, offset: 0x02b3 = 691
>> FAT16: ret: 0x000002b4, entry: 0x000002b3, offset: 0x02b3
>> FAT16: entry: 0x000002b4 = 692, offset: 0x02b4 = 692
>> FAT16: ret: 0x000002b5, entry: 0x000002b4, offset: 0x02b4
>> FAT16: entry: 0x000002b5 = 693, offset: 0x02b5 = 693
>> FAT16: ret: 0x000002b6, entry: 0x000002b5, offset: 0x02b5
>> FAT16: entry: 0x000002b6 = 694, offset: 0x02b6 = 694
>> FAT16: ret: 0x000002b7, entry: 0x000002b6, offset: 0x02b6
>> FAT16: entry: 0x000002b7 = 695, offset: 0x02b7 = 695
>> FAT16: ret: 0x000002b8, entry: 0x000002b7, offset: 0x02b7
>> FAT16: entry: 0x000002b8 = 696, offset: 0x02b8 = 696
>> FAT16: ret: 0x000002b9, entry: 0x000002b8, offset: 0x02b8
>> FAT16: entry: 0x000002b9 = 697, offset: 0x02b9 = 697
>> FAT16: ret: 0x000002ba, entry: 0x000002b9, offset: 0x02b9
>> FAT16: entry: 0x000002ba = 698, offset: 0x02ba = 698
>> FAT16: ret: 0x000002bb, entry: 0x000002ba, offset: 0x02ba
>> FAT16: entry: 0x000002bb = 699, offset: 0x02bb = 699
>> FAT16: ret: 0x000002bc, entry: 0x000002bb, offset: 0x02bb
>> FAT16: entry: 0x000002bc = 700, offset: 0x02bc = 700
>> FAT16: ret: 0x000002bd, entry: 0x000002bc, offset: 0x02bc
>> FAT16: entry: 0x000002bd = 701, offset: 0x02bd = 701
>> FAT16: ret: 0x000002be, entry: 0x000002bd, offset: 0x02bd
>> FAT16: entry: 0x000002be = 702, offset: 0x02be = 702
>> FAT16: ret: 0x000002bf, entry: 0x000002be, offset: 0x02be
>> FAT16: entry: 0x000002bf = 703, offset: 0x02bf = 703
>> FAT16: ret: 0x000002c0, entry: 0x000002bf, offset: 0x02bf
>> FAT16: entry: 0x000002c0 = 704, offset: 0x02c0 = 704
>> FAT16: ret: 0x000002c1, entry: 0x000002c0, offset: 0x02c0
>> FAT16: entry: 0x000002c1 = 705, offset: 0x02c1 = 705
>> FAT16: ret: 0x000002c2, entry: 0x000002c1, offset: 0x02c1
>> FAT16: entry: 0x000002c2 = 706, offset: 0x02c2 = 706
>> FAT16: ret: 0x000002c3, entry: 0x000002c2, offset: 0x02c2
>> FAT16: entry: 0x000002c3 = 707, offset: 0x02c3 = 707
>> FAT16: ret: 0x000002c4, entry: 0x000002c3, offset: 0x02c3
>> FAT16: entry: 0x000002c4 = 708, offset: 0x02c4 = 708
>> FAT16: ret: 0x000002c5, entry: 0x000002c4, offset: 0x02c4
>> FAT16: entry: 0x000002c5 = 709, offset: 0x02c5 = 709
>> FAT16: ret: 0x000002c6, entry: 0x000002c5, offset: 0x02c5
>> FAT16: entry: 0x000002c6 = 710, offset: 0x02c6 = 710
>> FAT16: ret: 0x000002c7, entry: 0x000002c6, offset: 0x02c6
>> FAT16: entry: 0x000002c7 = 711, offset: 0x02c7 = 711
>> FAT16: ret: 0x000002c8, entry: 0x000002c7, offset: 0x02c7
>> FAT16: entry: 0x000002c8 = 712, offset: 0x02c8 = 712
>> FAT16: ret: 0x000002c9, entry: 0x000002c8, offset: 0x02c8
>> FAT16: entry: 0x000002c9 = 713, offset: 0x02c9 = 713
>> FAT16: ret: 0x000002ca, entry: 0x000002c9, offset: 0x02c9
>> FAT16: entry: 0x000002ca = 714, offset: 0x02ca = 714
>> FAT16: ret: 0x000002cb, entry: 0x000002ca, offset: 0x02ca
>> FAT16: entry: 0x000002cb = 715, offset: 0x02cb = 715
>> FAT16: ret: 0x000002cc, entry: 0x000002cb, offset: 0x02cb
>> FAT16: entry: 0x000002cc = 716, offset: 0x02cc = 716
>> FAT16: ret: 0x000002cd, entry: 0x000002cc, offset: 0x02cc
>> FAT16: entry: 0x000002cd = 717, offset: 0x02cd = 717
>> FAT16: ret: 0x000002ce, entry: 0x000002cd, offset: 0x02cd
>> FAT16: entry: 0x000002ce = 718, offset: 0x02ce = 718
>> FAT16: ret: 0x000002ef, entry: 0x000002ce, offset: 0x02ce
>> gc - clustnum: 525, startsect: 2525
>> FAT16: entry: 0x000002ce = 718, offset: 0x02ce = 718
>> FAT16: ret: 0x000002ef, entry: 0x000002ce, offset: 0x02ce
>> FAT16: entry: 0x000002ef = 751, offset: 0x02ef = 751
>> FAT16: ret: 0x000002f0, entry: 0x000002ef, offset: 0x02ef
>> FAT16: entry: 0x000002f0 = 752, offset: 0x02f0 = 752
>> FAT16: ret: 0x000002f1, entry: 0x000002f0, offset: 0x02f0
>> FAT16: entry: 0x000002f1 = 753, offset: 0x02f1 = 753
>> FAT16: ret: 0x000002f2, entry: 0x000002f1, offset: 0x02f1
>> FAT16: entry: 0x000002f2 = 754, offset: 0x02f2 = 754
>> FAT16: ret: 0x000002f3, entry: 0x000002f2, offset: 0x02f2
>> FAT16: entry: 0x000002f3 = 755, offset: 0x02f3 = 755
>> FAT16: ret: 0x000002f4, entry: 0x000002f3, offset: 0x02f3
>> FAT16: entry: 0x000002f4 = 756, offset: 0x02f4 = 756
>> FAT16: ret: 0x000002f5, entry: 0x000002f4, offset: 0x02f4
>> FAT16: entry: 0x000002f5 = 757, offset: 0x02f5 = 757
>> FAT16: ret: 0x000002f6, entry: 0x000002f5, offset: 0x02f5
>> FAT16: entry: 0x000002f6 = 758, offset: 0x02f6 = 758
>> FAT16: ret: 0x000002f7, entry: 0x000002f6, offset: 0x02f6
>> FAT16: entry: 0x000002f7 = 759, offset: 0x02f7 = 759
>> FAT16: ret: 0x000002f8, entry: 0x000002f7, offset: 0x02f7
>> FAT16: entry: 0x000002f8 = 760, offset: 0x02f8 = 760
>> FAT16: ret: 0x000002f9, entry: 0x000002f8, offset: 0x02f8
>> FAT16: entry: 0x000002f9 = 761, offset: 0x02f9 = 761
>> FAT16: ret: 0x000002fa, entry: 0x000002f9, offset: 0x02f9
>> FAT16: entry: 0x000002fa = 762, offset: 0x02fa = 762
>> FAT16: ret: 0x000002fb, entry: 0x000002fa, offset: 0x02fa
>> FAT16: entry: 0x000002fb = 763, offset: 0x02fb = 763
>> FAT16: ret: 0x000002fc, entry: 0x000002fb, offset: 0x02fb
>> FAT16: entry: 0x000002fc = 764, offset: 0x02fc = 764
>> FAT16: ret: 0x000002fd, entry: 0x000002fc, offset: 0x02fc
>> FAT16: entry: 0x000002fd = 765, offset: 0x02fd = 765
>> FAT16: ret: 0x000002fe, entry: 0x000002fd, offset: 0x02fd
>> FAT16: entry: 0x000002fe = 766, offset: 0x02fe = 766
>> FAT16: ret: 0x000002ff, entry: 0x000002fe, offset: 0x02fe
>> FAT16: entry: 0x000002ff = 767, offset: 0x02ff = 767
>> FAT16: ret: 0x00000300, entry: 0x000002ff, offset: 0x02ff
>> FAT16: entry: 0x00000300 = 768, offset: 0x0300 = 768
>> FAT16: ret: 0x00000301, entry: 0x00000300, offset: 0x0300
>> FAT16: entry: 0x00000301 = 769, offset: 0x0301 = 769
>> FAT16: ret: 0x00000302, entry: 0x00000301, offset: 0x0301
>> FAT16: entry: 0x00000302 = 770, offset: 0x0302 = 770
>> FAT16: ret: 0x00000303, entry: 0x00000302, offset: 0x0302
>> FAT16: entry: 0x00000303 = 771, offset: 0x0303 = 771
>> FAT16: ret: 0x00000304, entry: 0x00000303, offset: 0x0303
>> FAT16: entry: 0x00000304 = 772, offset: 0x0304 = 772
>> FAT16: ret: 0x00000305, entry: 0x00000304, offset: 0x0304
>> FAT16: entry: 0x00000305 = 773, offset: 0x0305 = 773
>> FAT16: ret: 0x00000306, entry: 0x00000305, offset: 0x0305
>> FAT16: entry: 0x00000306 = 774, offset: 0x0306 = 774
>> FAT16: ret: 0x00000307, entry: 0x00000306, offset: 0x0306
>> FAT16: entry: 0x00000307 = 775, offset: 0x0307 = 775
>> FAT16: ret: 0x00000308, entry: 0x00000307, offset: 0x0307
>> FAT16: entry: 0x00000308 = 776, offset: 0x0308 = 776
>> FAT16: ret: 0x00000309, entry: 0x00000308, offset: 0x0308
>> FAT16: entry: 0x00000309 = 777, offset: 0x0309 = 777
>> FAT16: ret: 0x0000030a, entry: 0x00000309, offset: 0x0309
>> FAT16: entry: 0x0000030a = 778, offset: 0x030a = 778
>> FAT16: ret: 0x0000030b, entry: 0x0000030a, offset: 0x030a
>> FAT16: entry: 0x0000030b = 779, offset: 0x030b = 779
>> FAT16: ret: 0x0000030c, entry: 0x0000030b, offset: 0x030b
>> FAT16: entry: 0x0000030c = 780, offset: 0x030c = 780
>> FAT16: ret: 0x0000030d, entry: 0x0000030c, offset: 0x030c
>> FAT16: entry: 0x0000030d = 781, offset: 0x030d = 781
>> FAT16: ret: 0x0000030e, entry: 0x0000030d, offset: 0x030d
>> FAT16: entry: 0x0000030e = 782, offset: 0x030e = 782
>> FAT16: ret: 0x0000030f, entry: 0x0000030e, offset: 0x030e
>> FAT16: entry: 0x0000030f = 783, offset: 0x030f = 783
>> FAT16: ret: 0x00000310, entry: 0x0000030f, offset: 0x030f
>> FAT16: entry: 0x00000310 = 784, offset: 0x0310 = 784
>> FAT16: ret: 0x00000311, entry: 0x00000310, offset: 0x0310
>> FAT16: entry: 0x00000311 = 785, offset: 0x0311 = 785
>> FAT16: ret: 0x00000312, entry: 0x00000311, offset: 0x0311
>> FAT16: entry: 0x00000312 = 786, offset: 0x0312 = 786
>> FAT16: ret: 0x00000313, entry: 0x00000312, offset: 0x0312
>> FAT16: entry: 0x00000313 = 787, offset: 0x0313 = 787
>> FAT16: ret: 0x00000314, entry: 0x00000313, offset: 0x0313
>> FAT16: entry: 0x00000314 = 788, offset: 0x0314 = 788
>> FAT16: ret: 0x00000315, entry: 0x00000314, offset: 0x0314
>> FAT16: entry: 0x00000315 = 789, offset: 0x0315 = 789
>> FAT16: ret: 0x00000316, entry: 0x00000315, offset: 0x0315
>> FAT16: entry: 0x00000316 = 790, offset: 0x0316 = 790
>> FAT16: ret: 0x00000317, entry: 0x00000316, offset: 0x0316
>> FAT16: entry: 0x00000317 = 791, offset: 0x0317 = 791
>> FAT16: ret: 0x00000318, entry: 0x00000317, offset: 0x0317
>> FAT16: entry: 0x00000318 = 792, offset: 0x0318 = 792
>> FAT16: ret: 0x00000319, entry: 0x00000318, offset: 0x0318
>> FAT16: entry: 0x00000319 = 793, offset: 0x0319 = 793
>> FAT16: ret: 0x0000031a, entry: 0x00000319, offset: 0x0319
>> FAT16: entry: 0x0000031a = 794, offset: 0x031a = 794
>> FAT16: ret: 0x0000031b, entry: 0x0000031a, offset: 0x031a
>> FAT16: entry: 0x0000031b = 795, offset: 0x031b = 795
>> FAT16: ret: 0x0000031c, entry: 0x0000031b, offset: 0x031b
>> FAT16: entry: 0x0000031c = 796, offset: 0x031c = 796
>> FAT16: ret: 0x0000031d, entry: 0x0000031c, offset: 0x031c
>> FAT16: entry: 0x0000031d = 797, offset: 0x031d = 797
>> FAT16: ret: 0x0000031e, entry: 0x0000031d, offset: 0x031d
>> FAT16: entry: 0x0000031e = 798, offset: 0x031e = 798
>> FAT16: ret: 0x0000031f, entry: 0x0000031e, offset: 0x031e
>> FAT16: entry: 0x0000031f = 799, offset: 0x031f = 799
>> FAT16: ret: 0x00000320, entry: 0x0000031f, offset: 0x031f
>> FAT16: entry: 0x00000320 = 800, offset: 0x0320 = 800
>> FAT16: ret: 0x00000321, entry: 0x00000320, offset: 0x0320
>> FAT16: entry: 0x00000321 = 801, offset: 0x0321 = 801
>> FAT16: ret: 0x00000322, entry: 0x00000321, offset: 0x0321
>> FAT16: entry: 0x00000322 = 802, offset: 0x0322 = 802
>> FAT16: ret: 0x00000323, entry: 0x00000322, offset: 0x0322
>> FAT16: entry: 0x00000323 = 803, offset: 0x0323 = 803
>> FAT16: ret: 0x00000324, entry: 0x00000323, offset: 0x0323
>> FAT16: entry: 0x00000324 = 804, offset: 0x0324 = 804
>> FAT16: ret: 0x00000325, entry: 0x00000324, offset: 0x0324
>> FAT16: entry: 0x00000325 = 805, offset: 0x0325 = 805
>> FAT16: ret: 0x00000326, entry: 0x00000325, offset: 0x0325
>> FAT16: entry: 0x00000326 = 806, offset: 0x0326 = 806
>> FAT16: ret: 0x00000327, entry: 0x00000326, offset: 0x0326
>> FAT16: entry: 0x00000327 = 807, offset: 0x0327 = 807
>> FAT16: ret: 0x00000328, entry: 0x00000327, offset: 0x0327
>> FAT16: entry: 0x00000328 = 808, offset: 0x0328 = 808
>> FAT16: ret: 0x00000329, entry: 0x00000328, offset: 0x0328
>> FAT16: entry: 0x00000329 = 809, offset: 0x0329 = 809
>> FAT16: ret: 0x0000032a, entry: 0x00000329, offset: 0x0329
>> FAT16: entry: 0x0000032a = 810, offset: 0x032a = 810
>> FAT16: ret: 0x0000032b, entry: 0x0000032a, offset: 0x032a
>> FAT16: entry: 0x0000032b = 811, offset: 0x032b = 811
>> FAT16: ret: 0x0000032c, entry: 0x0000032b, offset: 0x032b
>> FAT16: entry: 0x0000032c = 812, offset: 0x032c = 812
>> FAT16: ret: 0x0000032d, entry: 0x0000032c, offset: 0x032c
>> FAT16: entry: 0x0000032d = 813, offset: 0x032d = 813
>> FAT16: ret: 0x0000032e, entry: 0x0000032d, offset: 0x032d
>> FAT16: entry: 0x0000032e = 814, offset: 0x032e = 814
>> FAT16: ret: 0x0000032f, entry: 0x0000032e, offset: 0x032e
>> FAT16: entry: 0x0000032f = 815, offset: 0x032f = 815
>> FAT16: ret: 0x00000330, entry: 0x0000032f, offset: 0x032f
>> FAT16: entry: 0x00000330 = 816, offset: 0x0330 = 816
>> FAT16: ret: 0x00000331, entry: 0x00000330, offset: 0x0330
>> FAT16: entry: 0x00000331 = 817, offset: 0x0331 = 817
>> FAT16: ret: 0x00000332, entry: 0x00000331, offset: 0x0331
>> FAT16: entry: 0x00000332 = 818, offset: 0x0332 = 818
>> FAT16: ret: 0x00000333, entry: 0x00000332, offset: 0x0332
>> FAT16: entry: 0x00000333 = 819, offset: 0x0333 = 819
>> FAT16: ret: 0x00000334, entry: 0x00000333, offset: 0x0333
>> FAT16: entry: 0x00000334 = 820, offset: 0x0334 = 820
>> FAT16: ret: 0x00000335, entry: 0x00000334, offset: 0x0334
>> FAT16: entry: 0x00000335 = 821, offset: 0x0335 = 821
>> FAT16: ret: 0x00000336, entry: 0x00000335, offset: 0x0335
>> FAT16: entry: 0x00000336 = 822, offset: 0x0336 = 822
>> FAT16: ret: 0x00000337, entry: 0x00000336, offset: 0x0336
>> FAT16: entry: 0x00000337 = 823, offset: 0x0337 = 823
>> FAT16: ret: 0x00000338, entry: 0x00000337, offset: 0x0337
>> FAT16: entry: 0x00000338 = 824, offset: 0x0338 = 824
>> FAT16: ret: 0x00000339, entry: 0x00000338, offset: 0x0338
>> FAT16: entry: 0x00000339 = 825, offset: 0x0339 = 825
>> FAT16: ret: 0x0000033a, entry: 0x00000339, offset: 0x0339
>> FAT16: entry: 0x0000033a = 826, offset: 0x033a = 826
>> FAT16: ret: 0x0000033b, entry: 0x0000033a, offset: 0x033a
>> FAT16: entry: 0x0000033b = 827, offset: 0x033b = 827
>> FAT16: ret: 0x0000033c, entry: 0x0000033b, offset: 0x033b
>> FAT16: entry: 0x0000033c = 828, offset: 0x033c = 828
>> FAT16: ret: 0x0000033d, entry: 0x0000033c, offset: 0x033c
>> FAT16: entry: 0x0000033d = 829, offset: 0x033d = 829
>> FAT16: ret: 0x0000033e, entry: 0x0000033d, offset: 0x033d
>> FAT16: entry: 0x0000033e = 830, offset: 0x033e = 830
>> FAT16: ret: 0x0000033f, entry: 0x0000033e, offset: 0x033e
>> FAT16: entry: 0x0000033f = 831, offset: 0x033f = 831
>> FAT16: ret: 0x00000340, entry: 0x0000033f, offset: 0x033f
>> FAT16: entry: 0x00000340 = 832, offset: 0x0340 = 832
>> FAT16: ret: 0x00000341, entry: 0x00000340, offset: 0x0340
>> FAT16: entry: 0x00000341 = 833, offset: 0x0341 = 833
>> FAT16: ret: 0x00000342, entry: 0x00000341, offset: 0x0341
>> FAT16: entry: 0x00000342 = 834, offset: 0x0342 = 834
>> FAT16: ret: 0x00000343, entry: 0x00000342, offset: 0x0342
>> FAT16: entry: 0x00000343 = 835, offset: 0x0343 = 835
>> FAT16: ret: 0x00000344, entry: 0x00000343, offset: 0x0343
>> FAT16: entry: 0x00000344 = 836, offset: 0x0344 = 836
>> FAT16: ret: 0x00000345, entry: 0x00000344, offset: 0x0344
>> FAT16: entry: 0x00000345 = 837, offset: 0x0345 = 837
>> FAT16: ret: 0x00000346, entry: 0x00000345, offset: 0x0345
>> FAT16: entry: 0x00000346 = 838, offset: 0x0346 = 838
>> FAT16: ret: 0x00000347, entry: 0x00000346, offset: 0x0346
>> FAT16: entry: 0x00000347 = 839, offset: 0x0347 = 839
>> FAT16: ret: 0x00000348, entry: 0x00000347, offset: 0x0347
>> FAT16: entry: 0x00000348 = 840, offset: 0x0348 = 840
>> FAT16: ret: 0x00000349, entry: 0x00000348, offset: 0x0348
>> FAT16: entry: 0x00000349 = 841, offset: 0x0349 = 841
>> FAT16: ret: 0x0000034a, entry: 0x00000349, offset: 0x0349
>> FAT16: entry: 0x0000034a = 842, offset: 0x034a = 842
>> FAT16: ret: 0x0000034b, entry: 0x0000034a, offset: 0x034a
>> FAT16: entry: 0x0000034b = 843, offset: 0x034b = 843
>> FAT16: ret: 0x0000034c, entry: 0x0000034b, offset: 0x034b
>> FAT16: entry: 0x0000034c = 844, offset: 0x034c = 844
>> FAT16: ret: 0x0000034d, entry: 0x0000034c, offset: 0x034c
>> FAT16: entry: 0x0000034d = 845, offset: 0x034d = 845
>> FAT16: ret: 0x0000034e, entry: 0x0000034d, offset: 0x034d
>> FAT16: entry: 0x0000034e = 846, offset: 0x034e = 846
>> FAT16: ret: 0x0000034f, entry: 0x0000034e, offset: 0x034e
>> FAT16: entry: 0x0000034f = 847, offset: 0x034f = 847
>> FAT16: ret: 0x00000350, entry: 0x0000034f, offset: 0x034f
>> FAT16: entry: 0x00000350 = 848, offset: 0x0350 = 848
>> FAT16: ret: 0x00000351, entry: 0x00000350, offset: 0x0350
>> FAT16: entry: 0x00000351 = 849, offset: 0x0351 = 849
>> FAT16: ret: 0x00000352, entry: 0x00000351, offset: 0x0351
>> FAT16: entry: 0x00000352 = 850, offset: 0x0352 = 850
>> FAT16: ret: 0x00000353, entry: 0x00000352, offset: 0x0352
>> FAT16: entry: 0x00000353 = 851, offset: 0x0353 = 851
>> FAT16: ret: 0x00000354, entry: 0x00000353, offset: 0x0353
>> FAT16: entry: 0x00000354 = 852, offset: 0x0354 = 852
>> FAT16: ret: 0x00000355, entry: 0x00000354, offset: 0x0354
>> FAT16: entry: 0x00000355 = 853, offset: 0x0355 = 853
>> FAT16: ret: 0x00000356, entry: 0x00000355, offset: 0x0355
>> FAT16: entry: 0x00000356 = 854, offset: 0x0356 = 854
>> FAT16: ret: 0x00000357, entry: 0x00000356, offset: 0x0356
>> FAT16: entry: 0x00000357 = 855, offset: 0x0357 = 855
>> FAT16: ret: 0x00000358, entry: 0x00000357, offset: 0x0357
>> FAT16: entry: 0x00000358 = 856, offset: 0x0358 = 856
>> FAT16: ret: 0x00000359, entry: 0x00000358, offset: 0x0358
>> FAT16: entry: 0x00000359 = 857, offset: 0x0359 = 857
>> FAT16: ret: 0x0000035a, entry: 0x00000359, offset: 0x0359
>> FAT16: entry: 0x0000035a = 858, offset: 0x035a = 858
>> FAT16: ret: 0x0000035b, entry: 0x0000035a, offset: 0x035a
>> FAT16: entry: 0x0000035b = 859, offset: 0x035b = 859
>> FAT16: ret: 0x0000035c, entry: 0x0000035b, offset: 0x035b
>> FAT16: entry: 0x0000035c = 860, offset: 0x035c = 860
>> FAT16: ret: 0x0000035d, entry: 0x0000035c, offset: 0x035c
>> FAT16: entry: 0x0000035d = 861, offset: 0x035d = 861
>> FAT16: ret: 0x0000035e, entry: 0x0000035d, offset: 0x035d
>> FAT16: entry: 0x0000035e = 862, offset: 0x035e = 862
>> FAT16: ret: 0x0000035f, entry: 0x0000035e, offset: 0x035e
>> FAT16: entry: 0x0000035f = 863, offset: 0x035f = 863
>> FAT16: ret: 0x00000360, entry: 0x0000035f, offset: 0x035f
>> FAT16: entry: 0x00000360 = 864, offset: 0x0360 = 864
>> FAT16: ret: 0x00000361, entry: 0x00000360, offset: 0x0360
>> FAT16: entry: 0x00000361 = 865, offset: 0x0361 = 865
>> FAT16: ret: 0x00000362, entry: 0x00000361, offset: 0x0361
>> FAT16: entry: 0x00000362 = 866, offset: 0x0362 = 866
>> FAT16: ret: 0x00000363, entry: 0x00000362, offset: 0x0362
>> FAT16: entry: 0x00000363 = 867, offset: 0x0363 = 867
>> FAT16: ret: 0x00000364, entry: 0x00000363, offset: 0x0363
>> FAT16: entry: 0x00000364 = 868, offset: 0x0364 = 868
>> FAT16: ret: 0x00000365, entry: 0x00000364, offset: 0x0364
>> FAT16: entry: 0x00000365 = 869, offset: 0x0365 = 869
>> FAT16: ret: 0x00000366, entry: 0x00000365, offset: 0x0365
>> FAT16: entry: 0x00000366 = 870, offset: 0x0366 = 870
>> FAT16: ret: 0x00000367, entry: 0x00000366, offset: 0x0366
>> FAT16: entry: 0x00000367 = 871, offset: 0x0367 = 871
>> FAT16: ret: 0x00000368, entry: 0x00000367, offset: 0x0367
>> FAT16: entry: 0x00000368 = 872, offset: 0x0368 = 872
>> FAT16: ret: 0x00000369, entry: 0x00000368, offset: 0x0368
>> FAT16: entry: 0x00000369 = 873, offset: 0x0369 = 873
>> FAT16: ret: 0x0000036a, entry: 0x00000369, offset: 0x0369
>> FAT16: entry: 0x0000036a = 874, offset: 0x036a = 874
>> FAT16: ret: 0x0000036b, entry: 0x0000036a, offset: 0x036a
>> FAT16: entry: 0x0000036b = 875, offset: 0x036b = 875
>> FAT16: ret: 0x0000036c, entry: 0x0000036b, offset: 0x036b
>> FAT16: entry: 0x0000036c = 876, offset: 0x036c = 876
>> FAT16: ret: 0x0000036d, entry: 0x0000036c, offset: 0x036c
>> FAT16: entry: 0x0000036d = 877, offset: 0x036d = 877
>> FAT16: ret: 0x0000036e, entry: 0x0000036d, offset: 0x036d
>> FAT16: entry: 0x0000036e = 878, offset: 0x036e = 878
>> FAT16: ret: 0x0000036f, entry: 0x0000036e, offset: 0x036e
>> FAT16: entry: 0x0000036f = 879, offset: 0x036f = 879
>> FAT16: ret: 0x00000370, entry: 0x0000036f, offset: 0x036f
>> FAT16: entry: 0x00000370 = 880, offset: 0x0370 = 880
>> FAT16: ret: 0x00000371, entry: 0x00000370, offset: 0x0370
>> FAT16: entry: 0x00000371 = 881, offset: 0x0371 = 881
>> FAT16: ret: 0x00000372, entry: 0x00000371, offset: 0x0371
>> FAT16: entry: 0x00000372 = 882, offset: 0x0372 = 882
>> FAT16: ret: 0x00000373, entry: 0x00000372, offset: 0x0372
>> FAT16: entry: 0x00000373 = 883, offset: 0x0373 = 883
>> FAT16: ret: 0x00000374, entry: 0x00000373, offset: 0x0373
>> FAT16: entry: 0x00000374 = 884, offset: 0x0374 = 884
>> FAT16: ret: 0x00000375, entry: 0x00000374, offset: 0x0374
>> FAT16: entry: 0x00000375 = 885, offset: 0x0375 = 885
>> FAT16: ret: 0x00000376, entry: 0x00000375, offset: 0x0375
>> FAT16: entry: 0x00000376 = 886, offset: 0x0376 = 886
>> FAT16: ret: 0x00000377, entry: 0x00000376, offset: 0x0376
>> FAT16: entry: 0x00000377 = 887, offset: 0x0377 = 887
>> FAT16: ret: 0x00000378, entry: 0x00000377, offset: 0x0377
>> FAT16: entry: 0x00000378 = 888, offset: 0x0378 = 888
>> FAT16: ret: 0x00000379, entry: 0x00000378, offset: 0x0378
>> FAT16: entry: 0x00000379 = 889, offset: 0x0379 = 889
>> FAT16: ret: 0x0000037a, entry: 0x00000379, offset: 0x0379
>> FAT16: entry: 0x0000037a = 890, offset: 0x037a = 890
>> FAT16: ret: 0x0000037b, entry: 0x0000037a, offset: 0x037a
>> FAT16: entry: 0x0000037b = 891, offset: 0x037b = 891
>> FAT16: ret: 0x0000037c, entry: 0x0000037b, offset: 0x037b
>> FAT16: entry: 0x0000037c = 892, offset: 0x037c = 892
>> FAT16: ret: 0x0000037d, entry: 0x0000037c, offset: 0x037c
>> FAT16: entry: 0x0000037d = 893, offset: 0x037d = 893
>> FAT16: ret: 0x0000037e, entry: 0x0000037d, offset: 0x037d
>> FAT16: entry: 0x0000037e = 894, offset: 0x037e = 894
>> FAT16: ret: 0x0000037f, entry: 0x0000037e, offset: 0x037e
>> FAT16: entry: 0x0000037f = 895, offset: 0x037f = 895
>> FAT16: ret: 0x00000380, entry: 0x0000037f, offset: 0x037f
>> FAT16: entry: 0x00000380 = 896, offset: 0x0380 = 896
>> FAT16: ret: 0x00000381, entry: 0x00000380, offset: 0x0380
>> FAT16: entry: 0x00000381 = 897, offset: 0x0381 = 897
>> FAT16: ret: 0x00000382, entry: 0x00000381, offset: 0x0381
>> FAT16: entry: 0x00000382 = 898, offset: 0x0382 = 898
>> FAT16: ret: 0x00000383, entry: 0x00000382, offset: 0x0382
>> FAT16: entry: 0x00000383 = 899, offset: 0x0383 = 899
>> FAT16: ret: 0x00000384, entry: 0x00000383, offset: 0x0383
>> FAT16: entry: 0x00000384 = 900, offset: 0x0384 = 900
>> FAT16: ret: 0x00000385, entry: 0x00000384, offset: 0x0384
>> FAT16: entry: 0x00000385 = 901, offset: 0x0385 = 901
>> FAT16: ret: 0x00000386, entry: 0x00000385, offset: 0x0385
>> FAT16: entry: 0x00000386 = 902, offset: 0x0386 = 902
>> FAT16: ret: 0x00000387, entry: 0x00000386, offset: 0x0386
>> FAT16: entry: 0x00000387 = 903, offset: 0x0387 = 903
>> FAT16: ret: 0x00000388, entry: 0x00000387, offset: 0x0387
>> FAT16: entry: 0x00000388 = 904, offset: 0x0388 = 904
>> FAT16: ret: 0x00000389, entry: 0x00000388, offset: 0x0388
>> FAT16: entry: 0x00000389 = 905, offset: 0x0389 = 905
>> FAT16: ret: 0x0000038a, entry: 0x00000389, offset: 0x0389
>> FAT16: entry: 0x0000038a = 906, offset: 0x038a = 906
>> FAT16: ret: 0x0000038b, entry: 0x0000038a, offset: 0x038a
>> FAT16: entry: 0x0000038b = 907, offset: 0x038b = 907
>> FAT16: ret: 0x0000038c, entry: 0x0000038b, offset: 0x038b
>> FAT16: entry: 0x0000038c = 908, offset: 0x038c = 908
>> FAT16: ret: 0x0000038d, entry: 0x0000038c, offset: 0x038c
>> FAT16: entry: 0x0000038d = 909, offset: 0x038d = 909
>> FAT16: ret: 0x0000038e, entry: 0x0000038d, offset: 0x038d
>> FAT16: entry: 0x0000038e = 910, offset: 0x038e = 910
>> FAT16: ret: 0x0000038f, entry: 0x0000038e, offset: 0x038e
>> FAT16: entry: 0x0000038f = 911, offset: 0x038f = 911
>> FAT16: ret: 0x00000390, entry: 0x0000038f, offset: 0x038f
>> FAT16: entry: 0x00000390 = 912, offset: 0x0390 = 912
>> FAT16: ret: 0x00000391, entry: 0x00000390, offset: 0x0390
>> FAT16: entry: 0x00000391 = 913, offset: 0x0391 = 913
>> FAT16: ret: 0x00000392, entry: 0x00000391, offset: 0x0391
>> FAT16: entry: 0x00000392 = 914, offset: 0x0392 = 914
>> FAT16: ret: 0x00000393, entry: 0x00000392, offset: 0x0392
>> FAT16: entry: 0x00000393 = 915, offset: 0x0393 = 915
>> FAT16: ret: 0x00000394, entry: 0x00000393, offset: 0x0393
>> FAT16: entry: 0x00000394 = 916, offset: 0x0394 = 916
>> FAT16: ret: 0x00000395, entry: 0x00000394, offset: 0x0394
>> FAT16: entry: 0x00000395 = 917, offset: 0x0395 = 917
>> FAT16: ret: 0x00000396, entry: 0x00000395, offset: 0x0395
>> FAT16: entry: 0x00000396 = 918, offset: 0x0396 = 918
>> FAT16: ret: 0x00000397, entry: 0x00000396, offset: 0x0396
>> FAT16: entry: 0x00000397 = 919, offset: 0x0397 = 919
>> FAT16: ret: 0x00000398, entry: 0x00000397, offset: 0x0397
>> FAT16: entry: 0x00000398 = 920, offset: 0x0398 = 920
>> FAT16: ret: 0x00000399, entry: 0x00000398, offset: 0x0398
>> FAT16: entry: 0x00000399 = 921, offset: 0x0399 = 921
>> FAT16: ret: 0x0000039a, entry: 0x00000399, offset: 0x0399
>> FAT16: entry: 0x0000039a = 922, offset: 0x039a = 922
>> FAT16: ret: 0x0000039b, entry: 0x0000039a, offset: 0x039a
>> FAT16: entry: 0x0000039b = 923, offset: 0x039b = 923
>> FAT16: ret: 0x0000039c, entry: 0x0000039b, offset: 0x039b
>> FAT16: entry: 0x0000039c = 924, offset: 0x039c = 924
>> FAT16: ret: 0x0000039d, entry: 0x0000039c, offset: 0x039c
>> FAT16: entry: 0x0000039d = 925, offset: 0x039d = 925
>> FAT16: ret: 0x0000039e, entry: 0x0000039d, offset: 0x039d
>> FAT16: entry: 0x0000039e = 926, offset: 0x039e = 926
>> FAT16: ret: 0x0000039f, entry: 0x0000039e, offset: 0x039e
>> FAT16: entry: 0x0000039f = 927, offset: 0x039f = 927
>> FAT16: ret: 0x000003a0, entry: 0x0000039f, offset: 0x039f
>> FAT16: entry: 0x000003a0 = 928, offset: 0x03a0 = 928
>> FAT16: ret: 0x000003a1, entry: 0x000003a0, offset: 0x03a0
>> FAT16: entry: 0x000003a1 = 929, offset: 0x03a1 = 929
>> FAT16: ret: 0x000003a2, entry: 0x000003a1, offset: 0x03a1
>> FAT16: entry: 0x000003a2 = 930, offset: 0x03a2 = 930
>> FAT16: ret: 0x000003a3, entry: 0x000003a2, offset: 0x03a2
>> FAT16: entry: 0x000003a3 = 931, offset: 0x03a3 = 931
>> FAT16: ret: 0x000003a4, entry: 0x000003a3, offset: 0x03a3
>> FAT16: entry: 0x000003a4 = 932, offset: 0x03a4 = 932
>> FAT16: ret: 0x000003a5, entry: 0x000003a4, offset: 0x03a4
>> FAT16: entry: 0x000003a5 = 933, offset: 0x03a5 = 933
>> FAT16: ret: 0x000003a6, entry: 0x000003a5, offset: 0x03a5
>> FAT16: entry: 0x000003a6 = 934, offset: 0x03a6 = 934
>> FAT16: ret: 0x000003a7, entry: 0x000003a6, offset: 0x03a6
>> FAT16: entry: 0x000003a7 = 935, offset: 0x03a7 = 935
>> FAT16: ret: 0x000003a8, entry: 0x000003a7, offset: 0x03a7
>> FAT16: entry: 0x000003a8 = 936, offset: 0x03a8 = 936
>> FAT16: ret: 0x000003a9, entry: 0x000003a8, offset: 0x03a8
>> FAT16: entry: 0x000003a9 = 937, offset: 0x03a9 = 937
>> FAT16: ret: 0x000003aa, entry: 0x000003a9, offset: 0x03a9
>> FAT16: entry: 0x000003aa = 938, offset: 0x03aa = 938
>> FAT16: ret: 0x000003ab, entry: 0x000003aa, offset: 0x03aa
>> FAT16: entry: 0x000003ab = 939, offset: 0x03ab = 939
>> FAT16: ret: 0x000003ac, entry: 0x000003ab, offset: 0x03ab
>> FAT16: entry: 0x000003ac = 940, offset: 0x03ac = 940
>> FAT16: ret: 0x000003ad, entry: 0x000003ac, offset: 0x03ac
>> FAT16: entry: 0x000003ad = 941, offset: 0x03ad = 941
>> FAT16: ret: 0x000003ae, entry: 0x000003ad, offset: 0x03ad
>> FAT16: entry: 0x000003ae = 942, offset: 0x03ae = 942
>> FAT16: ret: 0x000003af, entry: 0x000003ae, offset: 0x03ae
>> FAT16: entry: 0x000003af = 943, offset: 0x03af = 943
>> FAT16: ret: 0x000003b0, entry: 0x000003af, offset: 0x03af
>> FAT16: entry: 0x000003b0 = 944, offset: 0x03b0 = 944
>> FAT16: ret: 0x000003b1, entry: 0x000003b0, offset: 0x03b0
>> FAT16: entry: 0x000003b1 = 945, offset: 0x03b1 = 945
>> FAT16: ret: 0x000003b2, entry: 0x000003b1, offset: 0x03b1
>> FAT16: entry: 0x000003b2 = 946, offset: 0x03b2 = 946
>> FAT16: ret: 0x000003b3, entry: 0x000003b2, offset: 0x03b2
>> FAT16: entry: 0x000003b3 = 947, offset: 0x03b3 = 947
>> FAT16: ret: 0x000003b4, entry: 0x000003b3, offset: 0x03b3
>> FAT16: entry: 0x000003b4 = 948, offset: 0x03b4 = 948
>> FAT16: ret: 0x000003b5, entry: 0x000003b4, offset: 0x03b4
>> FAT16: entry: 0x000003b5 = 949, offset: 0x03b5 = 949
>> FAT16: ret: 0x000003b6, entry: 0x000003b5, offset: 0x03b5
>> FAT16: entry: 0x000003b6 = 950, offset: 0x03b6 = 950
>> FAT16: ret: 0x000003b7, entry: 0x000003b6, offset: 0x03b6
>> FAT16: entry: 0x000003b7 = 951, offset: 0x03b7 = 951
>> FAT16: ret: 0x000003b8, entry: 0x000003b7, offset: 0x03b7
>> FAT16: entry: 0x000003b8 = 952, offset: 0x03b8 = 952
>> FAT16: ret: 0x000003b9, entry: 0x000003b8, offset: 0x03b8
>> FAT16: entry: 0x000003b9 = 953, offset: 0x03b9 = 953
>> FAT16: ret: 0x000003ba, entry: 0x000003b9, offset: 0x03b9
>> FAT16: entry: 0x000003ba = 954, offset: 0x03ba = 954
>> FAT16: ret: 0x000003bb, entry: 0x000003ba, offset: 0x03ba
>> FAT16: entry: 0x000003bb = 955, offset: 0x03bb = 955
>> FAT16: ret: 0x000003bc, entry: 0x000003bb, offset: 0x03bb
>> FAT16: entry: 0x000003bc = 956, offset: 0x03bc = 956
>> FAT16: ret: 0x000003bd, entry: 0x000003bc, offset: 0x03bc
>> FAT16: entry: 0x000003bd = 957, offset: 0x03bd = 957
>> FAT16: ret: 0x000003be, entry: 0x000003bd, offset: 0x03bd
>> FAT16: entry: 0x000003be = 958, offset: 0x03be = 958
>> FAT16: ret: 0x000003bf, entry: 0x000003be, offset: 0x03be
>> FAT16: entry: 0x000003bf = 959, offset: 0x03bf = 959
>> FAT16: ret: 0x000003c0, entry: 0x000003bf, offset: 0x03bf
>> FAT16: entry: 0x000003c0 = 960, offset: 0x03c0 = 960
>> FAT16: ret: 0x000003c1, entry: 0x000003c0, offset: 0x03c0
>> FAT16: entry: 0x000003c1 = 961, offset: 0x03c1 = 961
>> FAT16: ret: 0x000003c2, entry: 0x000003c1, offset: 0x03c1
>> FAT16: entry: 0x000003c2 = 962, offset: 0x03c2 = 962
>> FAT16: ret: 0x000003c3, entry: 0x000003c2, offset: 0x03c2
>> FAT16: entry: 0x000003c3 = 963, offset: 0x03c3 = 963
>> FAT16: ret: 0x000003c4, entry: 0x000003c3, offset: 0x03c3
>> FAT16: entry: 0x000003c4 = 964, offset: 0x03c4 = 964
>> FAT16: ret: 0x000003c5, entry: 0x000003c4, offset: 0x03c4
>> FAT16: entry: 0x000003c5 = 965, offset: 0x03c5 = 965
>> FAT16: ret: 0x000003c6, entry: 0x000003c5, offset: 0x03c5
>> FAT16: entry: 0x000003c6 = 966, offset: 0x03c6 = 966
>> FAT16: ret: 0x000003c7, entry: 0x000003c6, offset: 0x03c6
>> FAT16: entry: 0x000003c7 = 967, offset: 0x03c7 = 967
>> FAT16: ret: 0x000003c8, entry: 0x000003c7, offset: 0x03c7
>> FAT16: entry: 0x000003c8 = 968, offset: 0x03c8 = 968
>> FAT16: ret: 0x000003c9, entry: 0x000003c8, offset: 0x03c8
>> FAT16: entry: 0x000003c9 = 969, offset: 0x03c9 = 969
>> FAT16: ret: 0x000003ca, entry: 0x000003c9, offset: 0x03c9
>> FAT16: entry: 0x000003ca = 970, offset: 0x03ca = 970
>> FAT16: ret: 0x000003cb, entry: 0x000003ca, offset: 0x03ca
>> FAT16: entry: 0x000003cb = 971, offset: 0x03cb = 971
>> FAT16: ret: 0x000003cc, entry: 0x000003cb, offset: 0x03cb
>> FAT16: entry: 0x000003cc = 972, offset: 0x03cc = 972
>> FAT16: ret: 0x000003cd, entry: 0x000003cc, offset: 0x03cc
>> FAT16: entry: 0x000003cd = 973, offset: 0x03cd = 973
>> FAT16: ret: 0x000003ce, entry: 0x000003cd, offset: 0x03cd
>> FAT16: entry: 0x000003ce = 974, offset: 0x03ce = 974
>> FAT16: ret: 0x000003cf, entry: 0x000003ce, offset: 0x03ce
>> FAT16: entry: 0x000003cf = 975, offset: 0x03cf = 975
>> FAT16: ret: 0x000003d0, entry: 0x000003cf, offset: 0x03cf
>> FAT16: entry: 0x000003d0 = 976, offset: 0x03d0 = 976
>> FAT16: ret: 0x000003d1, entry: 0x000003d0, offset: 0x03d0
>> FAT16: entry: 0x000003d1 = 977, offset: 0x03d1 = 977
>> FAT16: ret: 0x000003d2, entry: 0x000003d1, offset: 0x03d1
>> FAT16: entry: 0x000003d2 = 978, offset: 0x03d2 = 978
>> FAT16: ret: 0x000003d3, entry: 0x000003d2, offset: 0x03d2
>> FAT16: entry: 0x000003d3 = 979, offset: 0x03d3 = 979
>> FAT16: ret: 0x000003d4, entry: 0x000003d3, offset: 0x03d3
>> FAT16: entry: 0x000003d4 = 980, offset: 0x03d4 = 980
>> FAT16: ret: 0x000003d5, entry: 0x000003d4, offset: 0x03d4
>> FAT16: entry: 0x000003d5 = 981, offset: 0x03d5 = 981
>> FAT16: ret: 0x000003d6, entry: 0x000003d5, offset: 0x03d5
>> FAT16: entry: 0x000003d6 = 982, offset: 0x03d6 = 982
>> FAT16: ret: 0x000003d7, entry: 0x000003d6, offset: 0x03d6
>> FAT16: entry: 0x000003d7 = 983, offset: 0x03d7 = 983
>> FAT16: ret: 0x000003d8, entry: 0x000003d7, offset: 0x03d7
>> FAT16: entry: 0x000003d8 = 984, offset: 0x03d8 = 984
>> FAT16: ret: 0x000003d9, entry: 0x000003d8, offset: 0x03d8
>> FAT16: entry: 0x000003d9 = 985, offset: 0x03d9 = 985
>> FAT16: ret: 0x000003da, entry: 0x000003d9, offset: 0x03d9
>> FAT16: entry: 0x000003da = 986, offset: 0x03da = 986
>> FAT16: ret: 0x000003db, entry: 0x000003da, offset: 0x03da
>> FAT16: entry: 0x000003db = 987, offset: 0x03db = 987
>> FAT16: ret: 0x000003dc, entry: 0x000003db, offset: 0x03db
>> FAT16: entry: 0x000003dc = 988, offset: 0x03dc = 988
>> FAT16: ret: 0x000003dd, entry: 0x000003dc, offset: 0x03dc
>> FAT16: entry: 0x000003dd = 989, offset: 0x03dd = 989
>> FAT16: ret: 0x000003de, entry: 0x000003dd, offset: 0x03dd
>> FAT16: entry: 0x000003de = 990, offset: 0x03de = 990
>> FAT16: ret: 0x000003df, entry: 0x000003de, offset: 0x03de
>> FAT16: entry: 0x000003df = 991, offset: 0x03df = 991
>> FAT16: ret: 0x000003e0, entry: 0x000003df, offset: 0x03df
>> FAT16: entry: 0x000003e0 = 992, offset: 0x03e0 = 992
>> FAT16: ret: 0x000003e1, entry: 0x000003e0, offset: 0x03e0
>> FAT16: entry: 0x000003e1 = 993, offset: 0x03e1 = 993
>> FAT16: ret: 0x000003e2, entry: 0x000003e1, offset: 0x03e1
>> FAT16: entry: 0x000003e2 = 994, offset: 0x03e2 = 994
>> FAT16: ret: 0x000003e3, entry: 0x000003e2, offset: 0x03e2
>> FAT16: entry: 0x000003e3 = 995, offset: 0x03e3 = 995
>> FAT16: ret: 0x000003e4, entry: 0x000003e3, offset: 0x03e3
>> FAT16: entry: 0x000003e4 = 996, offset: 0x03e4 = 996
>> FAT16: ret: 0x000003e5, entry: 0x000003e4, offset: 0x03e4
>> FAT16: entry: 0x000003e5 = 997, offset: 0x03e5 = 997
>> FAT16: ret: 0x000003e6, entry: 0x000003e5, offset: 0x03e5
>> FAT16: entry: 0x000003e6 = 998, offset: 0x03e6 = 998
>> FAT16: ret: 0x000003e7, entry: 0x000003e6, offset: 0x03e6
>> FAT16: entry: 0x000003e7 = 999, offset: 0x03e7 = 999
>> FAT16: ret: 0x000003e8, entry: 0x000003e7, offset: 0x03e7
>> FAT16: entry: 0x000003e8 = 1000, offset: 0x03e8 = 1000
>> FAT16: ret: 0x000003e9, entry: 0x000003e8, offset: 0x03e8
>> FAT16: entry: 0x000003e9 = 1001, offset: 0x03e9 = 1001
>> FAT16: ret: 0x000003ea, entry: 0x000003e9, offset: 0x03e9
>> FAT16: entry: 0x000003ea = 1002, offset: 0x03ea = 1002
>> FAT16: ret: 0x000003eb, entry: 0x000003ea, offset: 0x03ea
>> FAT16: entry: 0x000003eb = 1003, offset: 0x03eb = 1003
>> FAT16: ret: 0x000003ec, entry: 0x000003eb, offset: 0x03eb
>> FAT16: entry: 0x000003ec = 1004, offset: 0x03ec = 1004
>> FAT16: ret: 0x000003ed, entry: 0x000003ec, offset: 0x03ec
>> FAT16: entry: 0x000003ed = 1005, offset: 0x03ed = 1005
>> FAT16: ret: 0x000003ee, entry: 0x000003ed, offset: 0x03ed
>> FAT16: entry: 0x000003ee = 1006, offset: 0x03ee = 1006
>> FAT16: ret: 0x000003ef, entry: 0x000003ee, offset: 0x03ee
>> FAT16: entry: 0x000003ef = 1007, offset: 0x03ef = 1007
>> FAT16: ret: 0x000003f0, entry: 0x000003ef, offset: 0x03ef
>> FAT16: entry: 0x000003f0 = 1008, offset: 0x03f0 = 1008
>> FAT16: ret: 0x000003f1, entry: 0x000003f0, offset: 0x03f0
>> FAT16: entry: 0x000003f1 = 1009, offset: 0x03f1 = 1009
>> FAT16: ret: 0x000003f2, entry: 0x000003f1, offset: 0x03f1
>> FAT16: entry: 0x000003f2 = 1010, offset: 0x03f2 = 1010
>> FAT16: ret: 0x000003f3, entry: 0x000003f2, offset: 0x03f2
>> FAT16: entry: 0x000003f3 = 1011, offset: 0x03f3 = 1011
>> FAT16: ret: 0x000003f4, entry: 0x000003f3, offset: 0x03f3
>> FAT16: entry: 0x000003f4 = 1012, offset: 0x03f4 = 1012
>> FAT16: ret: 0x000003f5, entry: 0x000003f4, offset: 0x03f4
>> FAT16: entry: 0x000003f5 = 1013, offset: 0x03f5 = 1013
>> FAT16: ret: 0x000003f6, entry: 0x000003f5, offset: 0x03f5
>> FAT16: entry: 0x000003f6 = 1014, offset: 0x03f6 = 1014
>> FAT16: ret: 0x000005f7, entry: 0x000003f6, offset: 0x03f6
>> gc - clustnum: 751, startsect: 3429
>> FAT16: entry: 0x000003f6 = 1014, offset: 0x03f6 = 1014
>> FAT16: ret: 0x000005f7, entry: 0x000003f6, offset: 0x03f6
>> FAT16: entry: 0x000005f7 = 1527, offset: 0x05f7 = 1527
>> FAT16: ret: 0x000005f8, entry: 0x000005f7, offset: 0x05f7
>> FAT16: entry: 0x000005f8 = 1528, offset: 0x05f8 = 1528
>> FAT16: ret: 0x000005f9, entry: 0x000005f8, offset: 0x05f8
>> FAT16: entry: 0x000005f9 = 1529, offset: 0x05f9 = 1529
>> FAT16: ret: 0x000005fa, entry: 0x000005f9, offset: 0x05f9
>> FAT16: entry: 0x000005fa = 1530, offset: 0x05fa = 1530
>> FAT16: ret: 0x000005fb, entry: 0x000005fa, offset: 0x05fa
>> FAT16: entry: 0x000005fb = 1531, offset: 0x05fb = 1531
>> FAT16: ret: 0x000005fc, entry: 0x000005fb, offset: 0x05fb
>> FAT16: entry: 0x000005fc = 1532, offset: 0x05fc = 1532
>> FAT16: ret: 0x000005fd, entry: 0x000005fc, offset: 0x05fc
>> FAT16: entry: 0x000005fd = 1533, offset: 0x05fd = 1533
>> FAT16: ret: 0x000005fe, entry: 0x000005fd, offset: 0x05fd
>> FAT16: entry: 0x000005fe = 1534, offset: 0x05fe = 1534
>> FAT16: ret: 0x000005ff, entry: 0x000005fe, offset: 0x05fe
>> FAT16: entry: 0x000005ff = 1535, offset: 0x05ff = 1535
>> FAT16: ret: 0x00000600, entry: 0x000005ff, offset: 0x05ff
>> FAT16: entry: 0x00000600 = 1536, offset: 0x0000 = 0
>> debug: evicting 0, dirty: 0
>> FAT16: ret: 0x00000601, entry: 0x00000600, offset: 0x0000
>> FAT16: entry: 0x00000601 = 1537, offset: 0x0001 = 1
>> FAT16: ret: 0x00000602, entry: 0x00000601, offset: 0x0001
>> FAT16: entry: 0x00000602 = 1538, offset: 0x0002 = 2
>> FAT16: ret: 0x00000603, entry: 0x00000602, offset: 0x0002
>> FAT16: entry: 0x00000603 = 1539, offset: 0x0003 = 3
>> FAT16: ret: 0x00000604, entry: 0x00000603, offset: 0x0003
>> FAT16: entry: 0x00000604 = 1540, offset: 0x0004 = 4
>> FAT16: ret: 0x00000605, entry: 0x00000604, offset: 0x0004
>> FAT16: entry: 0x00000605 = 1541, offset: 0x0005 = 5
>> FAT16: ret: 0x00000606, entry: 0x00000605, offset: 0x0005
>> FAT16: entry: 0x00000606 = 1542, offset: 0x0006 = 6
>> FAT16: ret: 0x00000607, entry: 0x00000606, offset: 0x0006
>> FAT16: entry: 0x00000607 = 1543, offset: 0x0007 = 7
>> FAT16: ret: 0x00000608, entry: 0x00000607, offset: 0x0007
>> FAT16: entry: 0x00000608 = 1544, offset: 0x0008 = 8
>> FAT16: ret: 0x00000609, entry: 0x00000608, offset: 0x0008
>> FAT16: entry: 0x00000609 = 1545, offset: 0x0009 = 9
>> FAT16: ret: 0x0000060a, entry: 0x00000609, offset: 0x0009
>> FAT16: entry: 0x0000060a = 1546, offset: 0x000a = 10
>> FAT16: ret: 0x0000060b, entry: 0x0000060a, offset: 0x000a
>> FAT16: entry: 0x0000060b = 1547, offset: 0x000b = 11
>> FAT16: ret: 0x0000060c, entry: 0x0000060b, offset: 0x000b
>> FAT16: entry: 0x0000060c = 1548, offset: 0x000c = 12
>> FAT16: ret: 0x0000060d, entry: 0x0000060c, offset: 0x000c
>> FAT16: entry: 0x0000060d = 1549, offset: 0x000d = 13
>> FAT16: ret: 0x0000060e, entry: 0x0000060d, offset: 0x000d
>> FAT16: entry: 0x0000060e = 1550, offset: 0x000e = 14
>> FAT16: ret: 0x0000060f, entry: 0x0000060e, offset: 0x000e
>> FAT16: entry: 0x0000060f = 1551, offset: 0x000f = 15
>> FAT16: ret: 0x00000610, entry: 0x0000060f, offset: 0x000f
>> FAT16: entry: 0x00000610 = 1552, offset: 0x0010 = 16
>> FAT16: ret: 0x00000611, entry: 0x00000610, offset: 0x0010
>> FAT16: entry: 0x00000611 = 1553, offset: 0x0011 = 17
>> FAT16: ret: 0x00000612, entry: 0x00000611, offset: 0x0011
>> FAT16: entry: 0x00000612 = 1554, offset: 0x0012 = 18
>> FAT16: ret: 0x00000613, entry: 0x00000612, offset: 0x0012
>> FAT16: entry: 0x00000613 = 1555, offset: 0x0013 = 19
>> FAT16: ret: 0x00000614, entry: 0x00000613, offset: 0x0013
>> FAT16: entry: 0x00000614 = 1556, offset: 0x0014 = 20
>> FAT16: ret: 0x00000615, entry: 0x00000614, offset: 0x0014
>> FAT16: entry: 0x00000615 = 1557, offset: 0x0015 = 21
>> FAT16: ret: 0x00000616, entry: 0x00000615, offset: 0x0015
>> FAT16: entry: 0x00000616 = 1558, offset: 0x0016 = 22
>> FAT16: ret: 0x00000617, entry: 0x00000616, offset: 0x0016
>> FAT16: entry: 0x00000617 = 1559, offset: 0x0017 = 23
>> FAT16: ret: 0x00000618, entry: 0x00000617, offset: 0x0017
>> FAT16: entry: 0x00000618 = 1560, offset: 0x0018 = 24
>> FAT16: ret: 0x00000619, entry: 0x00000618, offset: 0x0018
>> FAT16: entry: 0x00000619 = 1561, offset: 0x0019 = 25
>> FAT16: ret: 0x0000061a, entry: 0x00000619, offset: 0x0019
>> FAT16: entry: 0x0000061a = 1562, offset: 0x001a = 26
>> FAT16: ret: 0x0000061b, entry: 0x0000061a, offset: 0x001a
>> FAT16: entry: 0x0000061b = 1563, offset: 0x001b = 27
>> FAT16: ret: 0x0000061c, entry: 0x0000061b, offset: 0x001b
>> FAT16: entry: 0x0000061c = 1564, offset: 0x001c = 28
>> FAT16: ret: 0x0000061d, entry: 0x0000061c, offset: 0x001c
>> FAT16: entry: 0x0000061d = 1565, offset: 0x001d = 29
>> FAT16: ret: 0x0000061e, entry: 0x0000061d, offset: 0x001d
>> FAT16: entry: 0x0000061e = 1566, offset: 0x001e = 30
>> FAT16: ret: 0x0000061f, entry: 0x0000061e, offset: 0x001e
>> FAT16: entry: 0x0000061f = 1567, offset: 0x001f = 31
>> FAT16: ret: 0x00000620, entry: 0x0000061f, offset: 0x001f
>> FAT16: entry: 0x00000620 = 1568, offset: 0x0020 = 32
>> FAT16: ret: 0x00000621, entry: 0x00000620, offset: 0x0020
>> FAT16: entry: 0x00000621 = 1569, offset: 0x0021 = 33
>> FAT16: ret: 0x00000622, entry: 0x00000621, offset: 0x0021
>> FAT16: entry: 0x00000622 = 1570, offset: 0x0022 = 34
>> FAT16: ret: 0x00000623, entry: 0x00000622, offset: 0x0022
>> FAT16: entry: 0x00000623 = 1571, offset: 0x0023 = 35
>> FAT16: ret: 0x00000624, entry: 0x00000623, offset: 0x0023
>> FAT16: entry: 0x00000624 = 1572, offset: 0x0024 = 36
>> FAT16: ret: 0x00000625, entry: 0x00000624, offset: 0x0024
>> FAT16: entry: 0x00000625 = 1573, offset: 0x0025 = 37
>> FAT16: ret: 0x00000626, entry: 0x00000625, offset: 0x0025
>> FAT16: entry: 0x00000626 = 1574, offset: 0x0026 = 38
>> FAT16: ret: 0x00000627, entry: 0x00000626, offset: 0x0026
>> FAT16: entry: 0x00000627 = 1575, offset: 0x0027 = 39
>> FAT16: ret: 0x00000628, entry: 0x00000627, offset: 0x0027
>> FAT16: entry: 0x00000628 = 1576, offset: 0x0028 = 40
>> FAT16: ret: 0x00000629, entry: 0x00000628, offset: 0x0028
>> FAT16: entry: 0x00000629 = 1577, offset: 0x0029 = 41
>> FAT16: ret: 0x0000062a, entry: 0x00000629, offset: 0x0029
>> FAT16: entry: 0x0000062a = 1578, offset: 0x002a = 42
>> FAT16: ret: 0x0000062b, entry: 0x0000062a, offset: 0x002a
>> FAT16: entry: 0x0000062b = 1579, offset: 0x002b = 43
>> FAT16: ret: 0x0000062c, entry: 0x0000062b, offset: 0x002b
>> gc - clustnum: 1527, startsect: 6533
>> 1048576 bytes read in 5128 ms (199.2 KiB/s)
>> byte at 0x83061000 (0xca) != byte at 0x82061000 (0x8f)
>> Total of 397312 byte(s) were the same
>> =>
>>
>> On 11/09/2018 08:59, Akashi, Takahiro wrote:
>>> From: AKASHI Takahiro <takahiro.akashi@linaro.org>
>>>
>>> In this patch, all the necessary code for allowing for a file offset
>>> at write is implemented. What plays a major roll here is get_set_cluster(),
>>> which, in contrast to its counterpart, set_cluster(), only operates on
>>> already-allocated clusters, overwriting with data.
>>>
>>> So, with a file offset specified, set_contents() seeks and writes data
>>> with set_get_cluster() until the end of a file, and, once it reaches
>>> there, continues writing with set_cluster() for the rest.
>>>
>>> Please note that a file will be trimmed as a result of write operation if
>>> write ends before reaching file's end. This is an intended behavior
>>> in order to maintain compatibility with the current interface.
>>>
>>> Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
>>> ---
>>>    fs/fat/fat_write.c | 288 ++++++++++++++++++++++++++++++++++++++++++---
>>>    1 file changed, 273 insertions(+), 15 deletions(-)
>>>
>>> diff --git a/fs/fat/fat_write.c b/fs/fat/fat_write.c
>>> index c22d8c7a46a1..651c7866debc 100644
>>> --- a/fs/fat/fat_write.c
>>> +++ b/fs/fat/fat_write.c
>>> @@ -450,6 +450,121 @@ set_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer,
>>>        return 0;
>>>    }
>>>
>> _______________________________________________
>> U-Boot mailing list
>> U-Boot at lists.denx.de
>> https://lists.denx.de/listinfo/u-boot

[U-Boot] [PATCH v3 10/26] fs: fat: support write with non-zero offset

[Heinrich Schuchardt]

On 10/31/2018 01:22 PM, Alexander Graf wrote:
> On 10/31/2018 11:00 AM, Clément Péron wrote:
>> Hi,
>>
>> Trying to rebuild my SoCFPGA Cyclone V board and got this error :
>>
>> fs/built-in.o: In function `set_contents':
>> /home/cperon/u-boot/fs/fat/fat_write.c:831: undefined reference to
>> `__aeabi_ldivmod'
>> make: *** [Makefile:1381: u-boot] Error 1
>>
>> seems to be introduced with this operation :
>> assert(!(cur_pos % bytesperclust));
> 
> Could we maybe just use a bitmask for bytesperclust?
> 
> 
> Alex

According to the FAT specification the cluster size is a power of two.
So we can write

assert(!(cur_pos & (bytesperclust -1)));

Cf. patch
https://lists.denx.de/pipermail/u-boot/2018-October/346178.html
fs: fat: validate sector and cluster size.

Best regards

Heinrich

[U-Boot] [PATCH v3 10/26] fs: fat: support write with non-zero offset

[AKASHI Takahiro]

On Wed, Oct 31, 2018 at 09:54:14PM +0100, Heinrich Schuchardt wrote:
> On 10/31/2018 01:22 PM, Alexander Graf wrote:
> > On 10/31/2018 11:00 AM, Clément Péron wrote:
> >> Hi,
> >>
> >> Trying to rebuild my SoCFPGA Cyclone V board and got this error :
> >>
> >> fs/built-in.o: In function `set_contents':
> >> /home/cperon/u-boot/fs/fat/fat_write.c:831: undefined reference to
> >> `__aeabi_ldivmod'
> >> make: *** [Makefile:1381: u-boot] Error 1
> >>
> >> seems to be introduced with this operation :
> >> assert(!(cur_pos % bytesperclust));
> > 
> > Could we maybe just use a bitmask for bytesperclust?
> > 
> > 
> > Alex
> 
> According to the FAT specification the cluster size is a power of two.
> So we can write

I found:
"Count of bytes per sector. This value may take on
 only the following values: 512, 1024, 2048 or 4096."

> assert(!(cur_pos & (bytesperclust -1)));

It seems reasonably good.

Thanks,
-Takahiro Akashi

> Cf. patch
> https://lists.denx.de/pipermail/u-boot/2018-October/346178.html
> fs: fat: validate sector and cluster size.
> 
> Best regards
> 
> Heinrich

[U-Boot] [PATCH v3 10/26] fs: fat: support write with non-zero offset

[Clément Péron]

Hi,

On Thu, 1 Nov 2018 at 06:08, AKASHI Takahiro <takahiro.akashi@linaro.org> wrote:
>
> On Wed, Oct 31, 2018 at 09:54:14PM +0100, Heinrich Schuchardt wrote:
> > On 10/31/2018 01:22 PM, Alexander Graf wrote:
> > > On 10/31/2018 11:00 AM, Clément Péron wrote:
> > >> Hi,
> > >>
> > >> Trying to rebuild my SoCFPGA Cyclone V board and got this error :
> > >>
> > >> fs/built-in.o: In function `set_contents':
> > >> /home/cperon/u-boot/fs/fat/fat_write.c:831: undefined reference to
> > >> `__aeabi_ldivmod'
> > >> make: *** [Makefile:1381: u-boot] Error 1
> > >>
> > >> seems to be introduced with this operation :
> > >> assert(!(cur_pos % bytesperclust));
> > >
> > > Could we maybe just use a bitmask for bytesperclust?
> > >
> > >
> > > Alex
> >
> > According to the FAT specification the cluster size is a power of two.
> > So we can write
>
> I found:
> "Count of bytes per sector. This value may take on
>  only the following values: 512, 1024, 2048 or 4096."
>
> > assert(!(cur_pos & (bytesperclust -1)));

Seems perfect ! Could you propose a patch for this ?

Thanks,
Clement

>
> It seems reasonably good.
>
> Thanks,
> -Takahiro Akashi
>
> > Cf. patch
> > https://lists.denx.de/pipermail/u-boot/2018-October/346178.html
> > fs: fat: validate sector and cluster size.
> >
> > Best regards
> >
> > Heinrich

[U-Boot] [BUG] cb8af8af5ba0 "fs: fat: support write with non-zero offset" leads to link error

[Heinrich Schuchardt]

On 9/11/18 8:59 AM, Akashi, Takahiro wrote:
> From: AKASHI Takahiro <takahiro.akashi@linaro.org>
> 
> In this patch, all the necessary code for allowing for a file offset
> at write is implemented. What plays a major roll here is get_set_cluster(),
> which, in contrast to its counterpart, set_cluster(), only operates on
> already-allocated clusters, overwriting with data.
> 
> So, with a file offset specified, set_contents() seeks and writes data
> with set_get_cluster() until the end of a file, and, once it reaches
> there, continues writing with set_cluster() for the rest.
> 
> Please note that a file will be trimmed as a result of write operation if
> write ends before reaching file's end. This is an intended behavior
> in order to maintain compatibility with the current interface.
> 
> Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
> ---
>  fs/fat/fat_write.c | 288 ++++++++++++++++++++++++++++++++++++++++++---
>  1 file changed, 273 insertions(+), 15 deletions(-)
> 
> diff --git a/fs/fat/fat_write.c b/fs/fat/fat_write.c
> index c22d8c7a46a1..651c7866debc 100644
> --- a/fs/fat/fat_write.c
> +++ b/fs/fat/fat_write.c
> @@ -450,6 +450,121 @@ set_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer,
>  	return 0;
>  }
>  
> +static __u8 tmpbuf_cluster[MAX_CLUSTSIZE] __aligned(ARCH_DMA_MINALIGN);
> +
> +/*
> + * Read and modify data on existing and consecutive cluster blocks
> + */
> +static int
> +get_set_cluster(fsdata *mydata, __u32 clustnum, loff_t pos, __u8 *buffer,
> +		loff_t size, loff_t *gotsize)
> +{
> +	unsigned int bytesperclust = mydata->clust_size * mydata->sect_size;
> +	__u32 startsect;
> +	loff_t wsize;
> +	int clustcount, i, ret;
> +
> +	*gotsize = 0;
> +	if (!size)
> +		return 0;
> +
> +	assert(pos < bytesperclust);
> +	startsect = clust_to_sect(mydata, clustnum);
> +
> +	debug("clustnum: %d, startsect: %d, pos: %lld\n",
> +	      clustnum, startsect, pos);
> +
> +	/* partial write at beginning */
> +	if (pos) {
> +		wsize = min(bytesperclust - pos, size);
> +		ret = disk_read(startsect, mydata->clust_size, tmpbuf_cluster);
> +		if (ret != mydata->clust_size) {
> +			debug("Error reading data (got %d)\n", ret);
> +			return -1;
> +		}
> +
> +		memcpy(tmpbuf_cluster + pos, buffer, wsize);
> +		ret = disk_write(startsect, mydata->clust_size, tmpbuf_cluster);
> +		if (ret != mydata->clust_size) {
> +			debug("Error writing data (got %d)\n", ret);
> +			return -1;
> +		}
> +
> +		size -= wsize;
> +		buffer += wsize;
> +		*gotsize += wsize;
> +
> +		startsect += mydata->clust_size;
> +
> +		if (!size)
> +			return 0;
> +	}
> +
> +	/* full-cluster write */
> +	if (size >= bytesperclust) {
> +		clustcount = lldiv(size, bytesperclust);
> +
> +		if (!((unsigned long)buffer & (ARCH_DMA_MINALIGN - 1))) {
> +			wsize = clustcount * bytesperclust;
> +			ret = disk_write(startsect,
> +					 clustcount * mydata->clust_size,
> +					 buffer);
> +			if (ret != clustcount * mydata->clust_size) {
> +				debug("Error writing data (got %d)\n", ret);
> +				return -1;
> +			}
> +
> +			size -= wsize;
> +			buffer += wsize;
> +			*gotsize += wsize;
> +
> +			startsect += clustcount * mydata->clust_size;
> +		} else {
> +			for (i = 0; i < clustcount; i++) {
> +				memcpy(tmpbuf_cluster, buffer, bytesperclust);
> +				ret = disk_write(startsect,
> +						 mydata->clust_size,
> +						 tmpbuf_cluster);
> +				if (ret != mydata->clust_size) {
> +					debug("Error writing data (got %d)\n",
> +					      ret);
> +					return -1;
> +				}
> +
> +				size -= bytesperclust;
> +				buffer += bytesperclust;
> +				*gotsize += bytesperclust;
> +
> +				startsect += mydata->clust_size;
> +			}
> +		}
> +	}
> +
> +	/* partial write at end */
> +	if (size) {
> +		wsize = size;
> +		ret = disk_read(startsect, mydata->clust_size, tmpbuf_cluster);
> +		if (ret != mydata->clust_size) {
> +			debug("Error reading data (got %d)\n", ret);
> +			return -1;
> +		}
> +		memcpy(tmpbuf_cluster, buffer, wsize);
> +		ret = disk_write(startsect, mydata->clust_size, tmpbuf_cluster);
> +		if (ret != mydata->clust_size) {
> +			debug("Error writing data (got %d)\n", ret);
> +			return -1;
> +		}
> +
> +		size -= wsize;
> +		buffer += wsize;
> +		*gotsize += wsize;
> +	}
> +
> +	assert(!size);
> +
> +	return 0;
> +}
> +
>  /*
>   * Find the first empty cluster
>   */
> @@ -578,26 +693,158 @@ set_contents(fsdata *mydata, dir_entry *dentptr, loff_t pos, __u8 *buffer,
>  	unsigned int bytesperclust = mydata->clust_size * mydata->sect_size;
>  	__u32 curclust = START(dentptr);
>  	__u32 endclust = 0, newclust = 0;
> -	loff_t actsize;
> +	loff_t cur_pos, offset, actsize, wsize;
>  
>  	*gotsize = 0;
> -	filesize = maxsize;
> +	filesize = pos + maxsize;
>  
>  	debug("%llu bytes\n", filesize);
>  
> -	if (curclust) {
> -		/*
> -		 * release already-allocated clusters anyway
> -		 */
> -		if (clear_fatent(mydata, curclust)) {
> -			printf("Error: clearing FAT entries\n");
> +	if (!filesize) {
> +		if (!curclust)
> +			return 0;
> +		if (!CHECK_CLUST(curclust, mydata->fatsize) ||
> +		    IS_LAST_CLUST(curclust, mydata->fatsize)) {
> +			clear_fatent(mydata, curclust);
> +			set_start_cluster(mydata, dentptr, 0);
> +			return 0;
> +		}
> +		debug("curclust: 0x%x\n", curclust);
> +		debug("Invalid FAT entry\n");
> +		return -1;
> +	}
> +
> +	if (!curclust) {
> +		assert(pos == 0);
> +		goto set_clusters;
> +	}
> +
> +	/* go to cluster at pos */
> +	cur_pos = bytesperclust;
> +	while (1) {
> +		if (pos <= cur_pos)
> +			break;
> +		if (IS_LAST_CLUST(curclust, mydata->fatsize))
> +			break;
> +
> +		newclust = get_fatent(mydata, curclust);
> +		if (!IS_LAST_CLUST(newclust, mydata->fatsize) &&
> +		    CHECK_CLUST(newclust, mydata->fatsize)) {
> +			debug("curclust: 0x%x\n", curclust);
> +			debug("Invalid FAT entry\n");
>  			return -1;
>  		}
> +
> +		cur_pos += bytesperclust;
> +		curclust = newclust;
> +	}
> +	if (IS_LAST_CLUST(curclust, mydata->fatsize)) {
> +		assert(pos == cur_pos);
> +		goto set_clusters;
>  	}
>  
> -	curclust = find_empty_cluster(mydata);
> -	set_start_cluster(mydata, dentptr, curclust);
> +	assert(pos < cur_pos);
> +	cur_pos -= bytesperclust;
>  
> +	/* overwrite */
> +	assert(IS_LAST_CLUST(curclust, mydata->fatsize) ||
> +	       !CHECK_CLUST(curclust, mydata->fatsize));
> +
> +	while (1) {
> +		/* search for allocated consecutive clusters */
> +		actsize = bytesperclust;
> +		endclust = curclust;
> +		while (1) {
> +			if (filesize <= (cur_pos + actsize))
> +				break;
> +
> +			newclust = get_fatent(mydata, endclust);
> +
> +			if (IS_LAST_CLUST(newclust, mydata->fatsize))
> +				break;
> +			if (CHECK_CLUST(newclust, mydata->fatsize)) {
> +				debug("curclust: 0x%x\n", curclust);
> +				debug("Invalid FAT entry\n");
> +				return -1;
> +			}
> +
> +			actsize += bytesperclust;
> +			endclust = newclust;
> +		}
> +
> +		/* overwrite to <curclust..endclust> */
> +		if (pos < cur_pos)
> +			offset = 0;
> +		else
> +			offset = pos - cur_pos;
> +		wsize = min(cur_pos + actsize, filesize) - pos;
> +		if (get_set_cluster(mydata, curclust, offset,
> +				    buffer, wsize, &actsize)) {
> +			printf("Error get-and-setting cluster\n");
> +			return -1;
> +		}
> +		buffer += wsize;
> +		*gotsize += wsize;
> +		cur_pos += offset + wsize;
> +
> +		if (filesize <= cur_pos)
> +			break;
> +
> +		/* CHECK: newclust = get_fatent(mydata, endclust); */
> +
> +		if (IS_LAST_CLUST(newclust, mydata->fatsize))
> +			/* no more clusters */
> +			break;
> +
> +		curclust = newclust;
> +	}
> +
> +	if (filesize <= cur_pos) {
> +		/* no more write */
> +		newclust = get_fatent(mydata, endclust);
> +		if (!IS_LAST_CLUST(newclust, mydata->fatsize)) {
> +			/* truncate the rest */
> +			clear_fatent(mydata, newclust);
> +
> +			/* Mark end of file in FAT */
> +			if (mydata->fatsize == 12)
> +				newclust = 0xfff;
> +			else if (mydata->fatsize == 16)
> +				newclust = 0xffff;
> +			else if (mydata->fatsize == 32)
> +				newclust = 0xfffffff;
> +			set_fatent_value(mydata, endclust, newclust);
> +		}
> +
> +		return 0;
> +	}
> +
> +	curclust = endclust;
> +	filesize -= cur_pos;
> +	assert(!(cur_pos % bytesperclust));

This patch was merged as
cb8af8af5ba03ae8e0a7315b66bfcc46d5c55627

When compiled with DEBUG=1 the line above leads to a link error:

fs/fat/fat_write.c:831: undefined reference to `__aeabi_ldivmod'

We should use function do_div() for the division.

Best regards

Heinrich

[U-Boot] [BUG] cb8af8af5ba0 "fs: fat: support write with non-zero offset" fatwrite followed by fatload and then cmp fails

[Faiz Abbas]

Hi Akashi,

On 11/09/18 12:29 PM, Akashi, Takahiro wrote:
> From: AKASHI Takahiro <takahiro.akashi@linaro.org>
> 
> The current write implementation is quite simple: remove existing clusters
> and then allocating new ones and filling them with data. This, inevitably,
> enforces always writing from the beginning of a file.
> 
> As the first step to lift this restriction, fat_file_write() and
> set_contents() are modified to accept an additional parameter, file offset
> and further re-factored so that, in the next patch, all the necessary code
> will be put into set_contents().
> 
> Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
> ---

My fatwrite, fatload and compare tests are failing in MMC with this
commit. This is what I see:

=> fatwrite mmc 0 ${loadaddr} test 0x2000000
33554432 bytes written
=> fatload mmc 0 84000000 test
33554432 bytes read in 2149 ms (14.9 MiB/s)
=> cmp.b 82000000 84000000 0x2000000
byte at 0x820c5000 (0x85) != byte at 0x840c5000 (0x9d)
Total of 806912 byte(s) were the same
=>

Reverting this commit fixes this issue for me.

Thanks,
Faiz

[U-Boot] [BUG] cb8af8af5ba0 "fs: fat: support write with non-zero offset" fatwrite followed by fatload and then cmp fails

[Rizvi, Mohammad Faiz Abbas]

Tom,

On 3/12/2019 2:11 PM, Faiz Abbas wrote:
> Hi Akashi,
> 
> On 11/09/18 12:29 PM, Akashi, Takahiro wrote:
>> From: AKASHI Takahiro <takahiro.akashi@linaro.org>
>>
>> The current write implementation is quite simple: remove existing clusters
>> and then allocating new ones and filling them with data. This, inevitably,
>> enforces always writing from the beginning of a file.
>>
>> As the first step to lift this restriction, fat_file_write() and
>> set_contents() are modified to accept an additional parameter, file offset
>> and further re-factored so that, in the next patch, all the necessary code
>> will be put into set_contents().
>>
>> Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
>> ---
> 
> My fatwrite, fatload and compare tests are failing in MMC with this
> commit. This is what I see:
> 
> => fatwrite mmc 0 ${loadaddr} test 0x2000000
> 33554432 bytes written
> => fatload mmc 0 84000000 test
> 33554432 bytes read in 2149 ms (14.9 MiB/s)
> => cmp.b 82000000 84000000 0x2000000
> byte at 0x820c5000 (0x85) != byte at 0x840c5000 (0x9d)
> Total of 806912 byte(s) were the same
> =>
> 
> Reverting this commit fixes this issue for me.
> 
> Thanks,
> Faiz
> 

We have about 100 boards failing to boot from SD card because of fat
filesystem corruption in our test farm (likely) because of this patch. I
am afraid we will have to revert it until something stable can be
figured out. Will send out reverts tomorrow. Hopefully they can be
reviewed and merged quickly.

Thanks,
Faiz

[U-Boot] [BUG] cb8af8af5ba0 "fs: fat: support write with non-zero offset" fatwrite followed by fatload and then cmp fails

[Tom Rini]

On Wed, Mar 13, 2019 at 10:41:15PM +0530, Rizvi, Mohammad Faiz Abbas wrote:
> Tom,
> 
> On 3/12/2019 2:11 PM, Faiz Abbas wrote:
> > Hi Akashi,
> > 
> > On 11/09/18 12:29 PM, Akashi, Takahiro wrote:
> >> From: AKASHI Takahiro <takahiro.akashi@linaro.org>
> >>
> >> The current write implementation is quite simple: remove existing clusters
> >> and then allocating new ones and filling them with data. This, inevitably,
> >> enforces always writing from the beginning of a file.
> >>
> >> As the first step to lift this restriction, fat_file_write() and
> >> set_contents() are modified to accept an additional parameter, file offset
> >> and further re-factored so that, in the next patch, all the necessary code
> >> will be put into set_contents().
> >>
> >> Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
> >> ---
> > 
> > My fatwrite, fatload and compare tests are failing in MMC with this
> > commit. This is what I see:
> > 
> > => fatwrite mmc 0 ${loadaddr} test 0x2000000
> > 33554432 bytes written
> > => fatload mmc 0 84000000 test
> > 33554432 bytes read in 2149 ms (14.9 MiB/s)
> > => cmp.b 82000000 84000000 0x2000000
> > byte at 0x820c5000 (0x85) != byte at 0x840c5000 (0x9d)
> > Total of 806912 byte(s) were the same
> > =>
> > 
> > Reverting this commit fixes this issue for me.
> > 
> > Thanks,
> > Faiz
> > 
> 
> We have about 100 boards failing to boot from SD card because of fat
> filesystem corruption in our test farm (likely) because of this patch. I
> am afraid we will have to revert it until something stable can be
> figured out. Will send out reverts tomorrow. Hopefully they can be
> reviewed and merged quickly.

OK, thanks!

-- 
Tom
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: not available
URL: <http://lists.denx.de/pipermail/u-boot/attachments/20190313/86e0f695/attachment.sig>

[U-Boot] [BUG] cb8af8af5ba0 "fs: fat: support write with non-zero offset" fatwrite followed by fatload and then cmp fails

[Akashi, Takahiro]

Hi Faiz,

On Tue, Mar 12, 2019 at 02:11:08PM +0530, Faiz Abbas wrote:
> Hi Akashi,
> 
> On 11/09/18 12:29 PM, Akashi, Takahiro wrote:
> > From: AKASHI Takahiro <takahiro.akashi@linaro.org>
> > 
> > The current write implementation is quite simple: remove existing clusters
> > and then allocating new ones and filling them with data. This, inevitably,
> > enforces always writing from the beginning of a file.
> > 
> > As the first step to lift this restriction, fat_file_write() and
> > set_contents() are modified to accept an additional parameter, file offset
> > and further re-factored so that, in the next patch, all the necessary code
> > will be put into set_contents().
> > 
> > Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
> > ---
> 
> My fatwrite, fatload and compare tests are failing in MMC with this
> commit. This is what I see:
> 
> => fatwrite mmc 0 ${loadaddr} test 0x2000000
> 33554432 bytes written
> => fatload mmc 0 84000000 test
> 33554432 bytes read in 2149 ms (14.9 MiB/s)
> => cmp.b 82000000 84000000 0x2000000
> byte at 0x820c5000 (0x85) != byte at 0x840c5000 (0x9d)
> Total of 806912 byte(s) were the same
> =>

I tried, but could not reproduce this issue.
(v2019.04-rc2)

What I did was:
- On host, create a vfat file system and a random data file.
     dd of=vfat128M.img bs=1M count=128
     mkfs -t vfat vfat128M.img ; mount ...
     head -c 32m /dev/urandom > 32m.data

- On qemu, try fatwrite
  (try 1)
  => fatload scsi 0:0 50000000 /32m.data 2000000
  33554432 bytes read in 539 ms (59.4 MiB/s)
  => fatwrite scsi 0:0 50000000 /32m_w.data 2000000
  33554432 bytes written
  => fatls scsi 0:0 /
  33554432   32m.data
  33554432   32m_w.data

  2 file(s), 0 dir(s)

  => fatload scsi 0:0 52000000 /32m_w.data
  33554432 bytes read in 537 ms (59.6 MiB/s)
  => cmp.b 50000000 52000000 2000000
  Total of 33554432 byte(s) were the same

  (try 2)
  => fatwrite scsi 0:0 54000000 /32m_w2.data 2000000
  33554432 bytes written
  => fatload scsi 0:0 56000000 /32m_w2.data    
  33554432 bytes read in 537 ms (59.6 MiB/s)
  => cmp.b 54000000 56000000 2000000
  Total of 33554432 byte(s) were the same

- I also confirmed that 32m.data and 32m_w.data are the same
  on the host.

> Reverting this commit fixes this issue for me.

So, first let me ask some questions:
- What is the size of your mmc memory?
- How did you format it?
- How many files are already there in the root directory?

Thanks,
-Takahiro Akashi


> Thanks,
> Faiz
> 
> 
> 
> 
> 

[U-Boot] [BUG] cb8af8af5ba0 "fs: fat: support write with non-zero offset" fatwrite followed by fatload and then cmp fails

[Tom Rini]

On Mon, Mar 18, 2019 at 10:42:31AM +0900, Akashi, Takahiro wrote:
> Hi Faiz,
> 
> On Tue, Mar 12, 2019 at 02:11:08PM +0530, Faiz Abbas wrote:
> > Hi Akashi,
> > 
> > On 11/09/18 12:29 PM, Akashi, Takahiro wrote:
> > > From: AKASHI Takahiro <takahiro.akashi@linaro.org>
> > > 
> > > The current write implementation is quite simple: remove existing clusters
> > > and then allocating new ones and filling them with data. This, inevitably,
> > > enforces always writing from the beginning of a file.
> > > 
> > > As the first step to lift this restriction, fat_file_write() and
> > > set_contents() are modified to accept an additional parameter, file offset
> > > and further re-factored so that, in the next patch, all the necessary code
> > > will be put into set_contents().
> > > 
> > > Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
> > > ---
> > 
> > My fatwrite, fatload and compare tests are failing in MMC with this
> > commit. This is what I see:
> > 
> > => fatwrite mmc 0 ${loadaddr} test 0x2000000
> > 33554432 bytes written
> > => fatload mmc 0 84000000 test
> > 33554432 bytes read in 2149 ms (14.9 MiB/s)
> > => cmp.b 82000000 84000000 0x2000000
> > byte at 0x820c5000 (0x85) != byte at 0x840c5000 (0x9d)
> > Total of 806912 byte(s) were the same
> > =>
> 
> I tried, but could not reproduce this issue.
> (v2019.04-rc2)
> 
> What I did was:
> - On host, create a vfat file system and a random data file.
>      dd of=vfat128M.img bs=1M count=128
>      mkfs -t vfat vfat128M.img ; mount ...
>      head -c 32m /dev/urandom > 32m.data
> 
> - On qemu, try fatwrite
>   (try 1)
>   => fatload scsi 0:0 50000000 /32m.data 2000000
>   33554432 bytes read in 539 ms (59.4 MiB/s)
>   => fatwrite scsi 0:0 50000000 /32m_w.data 2000000
>   33554432 bytes written
>   => fatls scsi 0:0 /
>   33554432   32m.data
>   33554432   32m_w.data
> 
>   2 file(s), 0 dir(s)
> 
>   => fatload scsi 0:0 52000000 /32m_w.data
>   33554432 bytes read in 537 ms (59.6 MiB/s)
>   => cmp.b 50000000 52000000 2000000
>   Total of 33554432 byte(s) were the same
> 
>   (try 2)
>   => fatwrite scsi 0:0 54000000 /32m_w2.data 2000000
>   33554432 bytes written
>   => fatload scsi 0:0 56000000 /32m_w2.data    
>   33554432 bytes read in 537 ms (59.6 MiB/s)
>   => cmp.b 54000000 56000000 2000000
>   Total of 33554432 byte(s) were the same
> 
> - I also confirmed that 32m.data and 32m_w.data are the same
>   on the host.
> 
> > Reverting this commit fixes this issue for me.
> 
> So, first let me ask some questions:
> - What is the size of your mmc memory?
> - How did you format it?
> - How many files are already there in the root directory?

Since I think there's some timezone mismatches here, can you please try
your test in a loop?  And this is likely showing up on something like
am335x_evm or dra7xx_evm.  Thanks!

-- 
Tom
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: not available
URL: <http://lists.denx.de/pipermail/u-boot/attachments/20190317/c93584bf/attachment.sig>

[U-Boot] [BUG] cb8af8af5ba0 "fs: fat: support write with non-zero offset" fatwrite followed by fatload and then cmp fails

[Akashi, Takahiro]

On Sun, Mar 17, 2019 at 09:44:20PM -0400, Tom Rini wrote:
> On Mon, Mar 18, 2019 at 10:42:31AM +0900, Akashi, Takahiro wrote:
> > Hi Faiz,
> > 
> > On Tue, Mar 12, 2019 at 02:11:08PM +0530, Faiz Abbas wrote:
> > > Hi Akashi,
> > > 
> > > On 11/09/18 12:29 PM, Akashi, Takahiro wrote:
> > > > From: AKASHI Takahiro <takahiro.akashi@linaro.org>
> > > > 
> > > > The current write implementation is quite simple: remove existing clusters
> > > > and then allocating new ones and filling them with data. This, inevitably,
> > > > enforces always writing from the beginning of a file.
> > > > 
> > > > As the first step to lift this restriction, fat_file_write() and
> > > > set_contents() are modified to accept an additional parameter, file offset
> > > > and further re-factored so that, in the next patch, all the necessary code
> > > > will be put into set_contents().
> > > > 
> > > > Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
> > > > ---
> > > 
> > > My fatwrite, fatload and compare tests are failing in MMC with this
> > > commit. This is what I see:
> > > 
> > > => fatwrite mmc 0 ${loadaddr} test 0x2000000
> > > 33554432 bytes written
> > > => fatload mmc 0 84000000 test
> > > 33554432 bytes read in 2149 ms (14.9 MiB/s)
> > > => cmp.b 82000000 84000000 0x2000000
> > > byte at 0x820c5000 (0x85) != byte at 0x840c5000 (0x9d)
> > > Total of 806912 byte(s) were the same
> > > =>
> > 
> > I tried, but could not reproduce this issue.
> > (v2019.04-rc2)
> > 
> > What I did was:
> > - On host, create a vfat file system and a random data file.
> >      dd of=vfat128M.img bs=1M count=128
> >      mkfs -t vfat vfat128M.img ; mount ...
> >      head -c 32m /dev/urandom > 32m.data
> > 
> > - On qemu, try fatwrite
> >   (try 1)
> >   => fatload scsi 0:0 50000000 /32m.data 2000000
> >   33554432 bytes read in 539 ms (59.4 MiB/s)
> >   => fatwrite scsi 0:0 50000000 /32m_w.data 2000000
> >   33554432 bytes written
> >   => fatls scsi 0:0 /
> >   33554432   32m.data
> >   33554432   32m_w.data
> > 
> >   2 file(s), 0 dir(s)
> > 
> >   => fatload scsi 0:0 52000000 /32m_w.data
> >   33554432 bytes read in 537 ms (59.6 MiB/s)
> >   => cmp.b 50000000 52000000 2000000
> >   Total of 33554432 byte(s) were the same
> > 
> >   (try 2)
> >   => fatwrite scsi 0:0 54000000 /32m_w2.data 2000000
> >   33554432 bytes written
> >   => fatload scsi 0:0 56000000 /32m_w2.data    
> >   33554432 bytes read in 537 ms (59.6 MiB/s)
> >   => cmp.b 54000000 56000000 2000000
> >   Total of 33554432 byte(s) were the same
> > 
> > - I also confirmed that 32m.data and 32m_w.data are the same
> >   on the host.
> > 
> > > Reverting this commit fixes this issue for me.
> > 
> > So, first let me ask some questions:
> > - What is the size of your mmc memory?
> > - How did you format it?
> > - How many files are already there in the root directory?
> 
> Since I think there's some timezone mismatches here, can you please try
> your test in a loop?

I'm afraid that I don't get your point. "in a loop"?

> And this is likely showing up on something like
> am335x_evm or dra7xx_evm.  Thanks!

Do you mean that this might have board dependency?

Thanks,
-Takahiro Akashi

> -- 
> Tom

[U-Boot] [BUG] cb8af8af5ba0 "fs: fat: support write with non-zero offset" fatwrite followed by fatload and then cmp fails

[Tom Rini]

On Mon, Mar 18, 2019 at 10:57:37AM +0900, Akashi, Takahiro wrote:
> On Sun, Mar 17, 2019 at 09:44:20PM -0400, Tom Rini wrote:
> > On Mon, Mar 18, 2019 at 10:42:31AM +0900, Akashi, Takahiro wrote:
> > > Hi Faiz,
> > > 
> > > On Tue, Mar 12, 2019 at 02:11:08PM +0530, Faiz Abbas wrote:
> > > > Hi Akashi,
> > > > 
> > > > On 11/09/18 12:29 PM, Akashi, Takahiro wrote:
> > > > > From: AKASHI Takahiro <takahiro.akashi@linaro.org>
> > > > > 
> > > > > The current write implementation is quite simple: remove existing clusters
> > > > > and then allocating new ones and filling them with data. This, inevitably,
> > > > > enforces always writing from the beginning of a file.
> > > > > 
> > > > > As the first step to lift this restriction, fat_file_write() and
> > > > > set_contents() are modified to accept an additional parameter, file offset
> > > > > and further re-factored so that, in the next patch, all the necessary code
> > > > > will be put into set_contents().
> > > > > 
> > > > > Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
> > > > > ---
> > > > 
> > > > My fatwrite, fatload and compare tests are failing in MMC with this
> > > > commit. This is what I see:
> > > > 
> > > > => fatwrite mmc 0 ${loadaddr} test 0x2000000
> > > > 33554432 bytes written
> > > > => fatload mmc 0 84000000 test
> > > > 33554432 bytes read in 2149 ms (14.9 MiB/s)
> > > > => cmp.b 82000000 84000000 0x2000000
> > > > byte at 0x820c5000 (0x85) != byte at 0x840c5000 (0x9d)
> > > > Total of 806912 byte(s) were the same
> > > > =>
> > > 
> > > I tried, but could not reproduce this issue.
> > > (v2019.04-rc2)
> > > 
> > > What I did was:
> > > - On host, create a vfat file system and a random data file.
> > >      dd of=vfat128M.img bs=1M count=128
> > >      mkfs -t vfat vfat128M.img ; mount ...
> > >      head -c 32m /dev/urandom > 32m.data
> > > 
> > > - On qemu, try fatwrite
> > >   (try 1)
> > >   => fatload scsi 0:0 50000000 /32m.data 2000000
> > >   33554432 bytes read in 539 ms (59.4 MiB/s)
> > >   => fatwrite scsi 0:0 50000000 /32m_w.data 2000000
> > >   33554432 bytes written
> > >   => fatls scsi 0:0 /
> > >   33554432   32m.data
> > >   33554432   32m_w.data
> > > 
> > >   2 file(s), 0 dir(s)
> > > 
> > >   => fatload scsi 0:0 52000000 /32m_w.data
> > >   33554432 bytes read in 537 ms (59.6 MiB/s)
> > >   => cmp.b 50000000 52000000 2000000
> > >   Total of 33554432 byte(s) were the same
> > > 
> > >   (try 2)
> > >   => fatwrite scsi 0:0 54000000 /32m_w2.data 2000000
> > >   33554432 bytes written
> > >   => fatload scsi 0:0 56000000 /32m_w2.data    
> > >   33554432 bytes read in 537 ms (59.6 MiB/s)
> > >   => cmp.b 54000000 56000000 2000000
> > >   Total of 33554432 byte(s) were the same
> > > 
> > > - I also confirmed that 32m.data and 32m_w.data are the same
> > >   on the host.
> > > 
> > > > Reverting this commit fixes this issue for me.
> > > 
> > > So, first let me ask some questions:
> > > - What is the size of your mmc memory?
> > > - How did you format it?
> > > - How many files are already there in the root directory?
> > 
> > Since I think there's some timezone mismatches here, can you please try
> > your test in a loop?
> 
> I'm afraid that I don't get your point. "in a loop"?

Yes.  The process you describe above, put it in a script and let it run
over and over.

> > And this is likely showing up on something like
> > am335x_evm or dra7xx_evm.  Thanks!
> 
> Do you mean that this might have board dependency?

Well, you were asking about the size of the MMC memory, so those boards
might be a good place to look for clues that may differ from your setup.
Thanks!

-- 
Tom
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: not available
URL: <http://lists.denx.de/pipermail/u-boot/attachments/20190317/4b3556fb/attachment.sig>

[U-Boot] [BUG] cb8af8af5ba0 "fs: fat: support write with non-zero offset" fatwrite followed by fatload and then cmp fails

[Faiz Abbas]

Tom, Akashi,

On 18/03/19 7:29 AM, Tom Rini wrote:
> On Mon, Mar 18, 2019 at 10:57:37AM +0900, Akashi, Takahiro wrote:
>> On Sun, Mar 17, 2019 at 09:44:20PM -0400, Tom Rini wrote:
>>> On Mon, Mar 18, 2019 at 10:42:31AM +0900, Akashi, Takahiro wrote:
>>>> Hi Faiz,
>>>>
>>>> On Tue, Mar 12, 2019 at 02:11:08PM +0530, Faiz Abbas wrote:
>>>>> Hi Akashi,
>>>>>
>>>>> On 11/09/18 12:29 PM, Akashi, Takahiro wrote:
>>>>>> From: AKASHI Takahiro <takahiro.akashi@linaro.org>
>>>>>>
>>>>>> The current write implementation is quite simple: remove existing clusters
>>>>>> and then allocating new ones and filling them with data. This, inevitably,
>>>>>> enforces always writing from the beginning of a file.
>>>>>>
>>>>>> As the first step to lift this restriction, fat_file_write() and
>>>>>> set_contents() are modified to accept an additional parameter, file offset
>>>>>> and further re-factored so that, in the next patch, all the necessary code
>>>>>> will be put into set_contents().
>>>>>>
>>>>>> Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
>>>>>> ---
>>>>>
>>>>> My fatwrite, fatload and compare tests are failing in MMC with this
>>>>> commit. This is what I see:
>>>>>
>>>>> => fatwrite mmc 0 ${loadaddr} test 0x2000000
>>>>> 33554432 bytes written
>>>>> => fatload mmc 0 84000000 test
>>>>> 33554432 bytes read in 2149 ms (14.9 MiB/s)
>>>>> => cmp.b 82000000 84000000 0x2000000
>>>>> byte at 0x820c5000 (0x85) != byte at 0x840c5000 (0x9d)
>>>>> Total of 806912 byte(s) were the same
>>>>> =>
>>>>
>>>> I tried, but could not reproduce this issue.
>>>> (v2019.04-rc2)
>>>>
>>>> What I did was:
>>>> - On host, create a vfat file system and a random data file.
>>>>      dd of=vfat128M.img bs=1M count=128
>>>>      mkfs -t vfat vfat128M.img ; mount ...
>>>>      head -c 32m /dev/urandom > 32m.data
>>>>
>>>> - On qemu, try fatwrite
>>>>   (try 1)
>>>>   => fatload scsi 0:0 50000000 /32m.data 2000000
>>>>   33554432 bytes read in 539 ms (59.4 MiB/s)
>>>>   => fatwrite scsi 0:0 50000000 /32m_w.data 2000000
>>>>   33554432 bytes written
>>>>   => fatls scsi 0:0 /
>>>>   33554432   32m.data
>>>>   33554432   32m_w.data
>>>>
>>>>   2 file(s), 0 dir(s)
>>>>
>>>>   => fatload scsi 0:0 52000000 /32m_w.data
>>>>   33554432 bytes read in 537 ms (59.6 MiB/s)
>>>>   => cmp.b 50000000 52000000 2000000
>>>>   Total of 33554432 byte(s) were the same
>>>>
>>>>   (try 2)
>>>>   => fatwrite scsi 0:0 54000000 /32m_w2.data 2000000
>>>>   33554432 bytes written
>>>>   => fatload scsi 0:0 56000000 /32m_w2.data    
>>>>   33554432 bytes read in 537 ms (59.6 MiB/s)
>>>>   => cmp.b 54000000 56000000 2000000
>>>>   Total of 33554432 byte(s) were the same
>>>>
>>>> - I also confirmed that 32m.data and 32m_w.data are the same
>>>>   on the host.
>>>>
>>>>> Reverting this commit fixes this issue for me.
>>>>
>>>> So, first let me ask some questions:
>>>> - What is the size of your mmc memory?
It doesn't seem to be related to MMC size. It killed most of our boards
and all of them have different sized SD cards. The fat partition would
be around 100 MB on each.

>>>> - How did you format it?

Using the default ubuntu disks app.

>>>> - How many files are already there in the root directory?

Only MLO and U-boot.img

>>>
>>> Since I think there's some timezone mismatches here, can you please try
>>> your test in a loop?
>>
>> I'm afraid that I don't get your point. "in a loop"?
> 
> Yes.  The process you describe above, put it in a script and let it run
> over and over.
> 
>>> And this is likely showing up on something like
>>> am335x_evm or dra7xx_evm.  Thanks!>>
>> Do you mean that this might have board dependency?
> 
> Well, you were asking about the size of the MMC memory, so those boards
> might be a good place to look for clues that may differ from your setup.
> Thanks!
>

Unfortunately, I am unable to reproduce it now either. I tried it on
rc4, went back to offending commit and couldn't reproduce it there
either. I tried with different boards and with reformatted partitions
but it seems to have vanished. I will try out the read and write in a
loop that Tom suggested.

It would be a good idea if you could get fat filesystem on an MMC device
to reproduce it. It could be related to MMC only.

Thanks,
Faiz

[U-Boot] [BUG] cb8af8af5ba0 "fs: fat: support write with non-zero offset" fatwrite followed by fatload and then cmp fails

[Faiz Abbas]

Hi,

On 21/03/19 12:20 PM, Faiz Abbas wrote:
> Tom, Akashi,
> 
> On 18/03/19 7:29 AM, Tom Rini wrote:
>> On Mon, Mar 18, 2019 at 10:57:37AM +0900, Akashi, Takahiro wrote:
>>> On Sun, Mar 17, 2019 at 09:44:20PM -0400, Tom Rini wrote:
>>>> On Mon, Mar 18, 2019 at 10:42:31AM +0900, Akashi, Takahiro wrote:
>>>>> Hi Faiz,
>>>>>
>>>>> On Tue, Mar 12, 2019 at 02:11:08PM +0530, Faiz Abbas wrote:
>>>>>> Hi Akashi,
>>>>>>
>>>>>> On 11/09/18 12:29 PM, Akashi, Takahiro wrote:
>>>>>>> From: AKASHI Takahiro <takahiro.akashi@linaro.org>
>>>>>>>
>>>>>>> The current write implementation is quite simple: remove existing clusters
>>>>>>> and then allocating new ones and filling them with data. This, inevitably,
>>>>>>> enforces always writing from the beginning of a file.
>>>>>>>
>>>>>>> As the first step to lift this restriction, fat_file_write() and
>>>>>>> set_contents() are modified to accept an additional parameter, file offset
>>>>>>> and further re-factored so that, in the next patch, all the necessary code
>>>>>>> will be put into set_contents().
>>>>>>>
>>>>>>> Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org>
>>>>>>> ---
>>>>>>
>>>>>> My fatwrite, fatload and compare tests are failing in MMC with this
>>>>>> commit. This is what I see:
>>>>>>
>>>>>> => fatwrite mmc 0 ${loadaddr} test 0x2000000
>>>>>> 33554432 bytes written
>>>>>> => fatload mmc 0 84000000 test
>>>>>> 33554432 bytes read in 2149 ms (14.9 MiB/s)
>>>>>> => cmp.b 82000000 84000000 0x2000000
>>>>>> byte at 0x820c5000 (0x85) != byte at 0x840c5000 (0x9d)
>>>>>> Total of 806912 byte(s) were the same
>>>>>> =>
>>>>>
>>>>> I tried, but could not reproduce this issue.
>>>>> (v2019.04-rc2)
>>>>>
>>>>> What I did was:
>>>>> - On host, create a vfat file system and a random data file.
>>>>>      dd of=vfat128M.img bs=1M count=128
>>>>>      mkfs -t vfat vfat128M.img ; mount ...
>>>>>      head -c 32m /dev/urandom > 32m.data
>>>>>
>>>>> - On qemu, try fatwrite
>>>>>   (try 1)
>>>>>   => fatload scsi 0:0 50000000 /32m.data 2000000
>>>>>   33554432 bytes read in 539 ms (59.4 MiB/s)
>>>>>   => fatwrite scsi 0:0 50000000 /32m_w.data 2000000
>>>>>   33554432 bytes written
>>>>>   => fatls scsi 0:0 /
>>>>>   33554432   32m.data
>>>>>   33554432   32m_w.data
>>>>>
>>>>>   2 file(s), 0 dir(s)
>>>>>
>>>>>   => fatload scsi 0:0 52000000 /32m_w.data
>>>>>   33554432 bytes read in 537 ms (59.6 MiB/s)
>>>>>   => cmp.b 50000000 52000000 2000000
>>>>>   Total of 33554432 byte(s) were the same
>>>>>
>>>>>   (try 2)
>>>>>   => fatwrite scsi 0:0 54000000 /32m_w2.data 2000000
>>>>>   33554432 bytes written
>>>>>   => fatload scsi 0:0 56000000 /32m_w2.data    
>>>>>   33554432 bytes read in 537 ms (59.6 MiB/s)
>>>>>   => cmp.b 54000000 56000000 2000000
>>>>>   Total of 33554432 byte(s) were the same
>>>>>
>>>>> - I also confirmed that 32m.data and 32m_w.data are the same
>>>>>   on the host.
>>>>>
>>>>>> Reverting this commit fixes this issue for me.
>>>>>
>>>>> So, first let me ask some questions:
>>>>> - What is the size of your mmc memory?
> It doesn't seem to be related to MMC size. It killed most of our boards
> and all of them have different sized SD cards. The fat partition would
> be around 100 MB on each.
> 
>>>>> - How did you format it?
> 
> Using the default ubuntu disks app.
> 
>>>>> - How many files are already there in the root directory?
> 
> Only MLO and U-boot.img
> 
>>>>
>>>> Since I think there's some timezone mismatches here, can you please try
>>>> your test in a loop?
>>>
>>> I'm afraid that I don't get your point. "in a loop"?
>>
>> Yes.  The process you describe above, put it in a script and let it run
>> over and over.
>>
>>>> And this is likely showing up on something like
>>>> am335x_evm or dra7xx_evm.  Thanks!>>
>>> Do you mean that this might have board dependency?
>>
>> Well, you were asking about the size of the MMC memory, so those boards
>> might be a good place to look for clues that may differ from your setup.
>> Thanks!
>>
> 
> Unfortunately, I am unable to reproduce it now either. I tried it on
> rc4, went back to offending commit and couldn't reproduce it there
> either. I tried with different boards and with reformatted partitions
> but it seems to have vanished. I will try out the read and write in a
> loop that Tom suggested.
> 
> It would be a good idea if you could get fat filesystem on an MMC device
> to reproduce it. It could be related to MMC only.
> 

Update on this:

I saw the issue in rc4 on a dra76x-evm one time but its really hard to
find out the exact steps and successive tries have failed to reproduce
it. I did setup an infinite while loop with tftp, write, read-back and
compare of boot images again and again, but that doesn't reproduce it
either after a few tens of tries. It seems some random writes and
read-backs should be able to reproduce it. Any ideas on a randomized
stress test?

Thanks,
Faiz