[U-Boot] [PATCH v6 3/6] fat: interface changes to accomodate files greater than 2GB

Suriyan Ramasami suriyan.r at gmail.com
Tue Nov 4 03:49:59 CET 2014


Change the interface for the fat functions to take in an extra
parameter of type "loff_t *" to return the size. The return values of
these funtions now serve as an indicator of error conditions alone.

Signed-off-by: Suriyan Ramasami <suriyan.r at gmail.com>

---

Changes in v6:
* Simon - Split this into a separate patch

Changes in v5: None

 common/cmd_fat.c   |   9 ++--
 common/env_fat.c   |   4 +-
 fs/fat/fat.c       | 122 ++++++++++++++++++++++++++++-------------------------
 fs/fat/fat_write.c |  61 +++++++++++++++------------
 fs/fat/file.c      |   7 +--
 include/fat.h      |  19 +++++----
 6 files changed, 122 insertions(+), 100 deletions(-)

diff --git a/common/cmd_fat.c b/common/cmd_fat.c
index 633fbf1..c00fb28 100644
--- a/common/cmd_fat.c
+++ b/common/cmd_fat.c
@@ -100,7 +100,8 @@ U_BOOT_CMD(
 static int do_fat_fswrite(cmd_tbl_t *cmdtp, int flag,
 		int argc, char * const argv[])
 {
-	long size;
+	loff_t size;
+	int ret;
 	unsigned long addr;
 	unsigned long count;
 	block_dev_desc_t *dev_desc = NULL;
@@ -127,15 +128,15 @@ static int do_fat_fswrite(cmd_tbl_t *cmdtp, int flag,
 	count = simple_strtoul(argv[5], NULL, 16);
 
 	buf = map_sysmem(addr, count);
-	size = file_fat_write(argv[4], buf, count);
+	ret = file_fat_write(argv[4], buf, 0, count, &size);
 	unmap_sysmem(buf);
-	if (size == -1) {
+	if (ret < 0) {
 		printf("\n** Unable to write \"%s\" from %s %d:%d **\n",
 			argv[4], argv[1], dev, part);
 		return 1;
 	}
 
-	printf("%ld bytes written\n", size);
+	printf("%llu bytes written\n", size);
 
 	return 0;
 }
diff --git a/common/env_fat.c b/common/env_fat.c
index 8db0160..9a6ce63 100644
--- a/common/env_fat.c
+++ b/common/env_fat.c
@@ -41,6 +41,7 @@ int saveenv(void)
 	disk_partition_t info;
 	int dev, part;
 	int err;
+	loff_t size;
 
 	err = env_export(&env_new);
 	if (err)
@@ -59,7 +60,8 @@ int saveenv(void)
 		return 1;
 	}
 
-	err = file_fat_write(FAT_ENV_FILE, (void *)&env_new, sizeof(env_t));
+	err = file_fat_write(FAT_ENV_FILE, (void *)&env_new, sizeof(env_t),
+			     &size);
 	if (err == -1) {
 		printf("\n** Unable to write \"%s\" from %s%d:%d **\n",
 			FAT_ENV_FILE, FAT_ENV_INTERFACE, dev, part);
diff --git a/fs/fat/fat.c b/fs/fat/fat.c
index 561921f..8eb254b 100644
--- a/fs/fat/fat.c
+++ b/fs/fat/fat.c
@@ -317,32 +317,33 @@ get_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer, unsigned long size)
 /*
  * Read at most 'maxsize' bytes from 'pos' in the file associated with 'dentptr'
  * into 'buffer'.
- * Return the number of bytes read or -1 on fatal errors.
+ * Update the number of bytes read in *gotsize or return -1 on fatal errors.
  */
 __u8 get_contents_vfatname_block[MAX_CLUSTSIZE]
 	__aligned(ARCH_DMA_MINALIGN);
 
-static long
-get_contents(fsdata *mydata, dir_entry *dentptr, unsigned long pos,
-	     __u8 *buffer, unsigned long maxsize)
+static int
+get_contents(fsdata *mydata, dir_entry *dentptr, loff_t pos,
+	     __u8 *buffer, loff_t maxsize, loff_t *gotsize)
 {
-	unsigned long filesize = FAT2CPU32(dentptr->size), gotsize = 0;
+	loff_t filesize = FAT2CPU32(dentptr->size);
 	unsigned int bytesperclust = mydata->clust_size * mydata->sect_size;
 	__u32 curclust = START(dentptr);
 	__u32 endclust, newclust;
-	unsigned long actsize;
+	loff_t actsize;
 
-	debug("Filesize: %ld bytes\n", filesize);
+	*gotsize = 0;
+	debug("Filesize: %llu bytes\n", filesize);
 
 	if (pos >= filesize) {
-		debug("Read position past EOF: %lu\n", pos);
-		return gotsize;
+		debug("Read position past EOF: %llu\n", pos);
+		return 0;
 	}
 
 	if (maxsize > 0 && filesize > pos + maxsize)
 		filesize = pos + maxsize;
 
-	debug("%ld bytes\n", filesize);
+	debug("%llu bytes\n", filesize);
 
 	actsize = bytesperclust;
 
@@ -352,7 +353,7 @@ get_contents(fsdata *mydata, dir_entry *dentptr, unsigned long pos,
 		if (CHECK_CLUST(curclust, mydata->fatsize)) {
 			debug("curclust: 0x%x\n", curclust);
 			debug("Invalid FAT entry\n");
-			return gotsize;
+			return 0;
 		}
 		actsize += bytesperclust;
 	}
@@ -373,16 +374,16 @@ get_contents(fsdata *mydata, dir_entry *dentptr, unsigned long pos,
 		filesize -= actsize;
 		actsize -= pos;
 		memcpy(buffer, get_contents_vfatname_block + pos, actsize);
-		gotsize += actsize;
+		*gotsize += actsize;
 		if (!filesize)
-			return gotsize;
+			return 0;
 		buffer += actsize;
 
 		curclust = get_fatent(mydata, curclust);
 		if (CHECK_CLUST(curclust, mydata->fatsize)) {
 			debug("curclust: 0x%x\n", curclust);
 			debug("Invalid FAT entry\n");
-			return gotsize;
+			return 0;
 		}
 	}
 
@@ -398,7 +399,7 @@ get_contents(fsdata *mydata, dir_entry *dentptr, unsigned long pos,
 			if (CHECK_CLUST(newclust, mydata->fatsize)) {
 				debug("curclust: 0x%x\n", newclust);
 				debug("Invalid FAT entry\n");
-				return gotsize;
+				return 0;
 			}
 			endclust = newclust;
 			actsize += bytesperclust;
@@ -410,14 +411,14 @@ get_contents(fsdata *mydata, dir_entry *dentptr, unsigned long pos,
 			printf("Error reading cluster\n");
 			return -1;
 		}
-		gotsize += actsize;
-		return gotsize;
+		*gotsize += actsize;
+		return 0;
 getit:
 		if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
 			printf("Error reading cluster\n");
 			return -1;
 		}
-		gotsize += (int)actsize;
+		*gotsize += (int)actsize;
 		filesize -= actsize;
 		buffer += actsize;
 
@@ -425,7 +426,7 @@ getit:
 		if (CHECK_CLUST(curclust, mydata->fatsize)) {
 			debug("curclust: 0x%x\n", curclust);
 			printf("Invalid FAT entry\n");
-			return gotsize;
+			return 0;
 		}
 		actsize = bytesperclust;
 		endclust = curclust;
@@ -633,8 +634,8 @@ static dir_entry *get_dentfromdir(fsdata *mydata, int startsect,
 						}
 						if (doit) {
 							if (dirc == ' ') {
-								printf(" %8ld   %s%c\n",
-									(long)FAT2CPU32(dentptr->size),
+								printf(" %8u   %s%c\n",
+								       FAT2CPU32(dentptr->size),
 									l_name,
 									dirc);
 							} else {
@@ -690,8 +691,8 @@ static dir_entry *get_dentfromdir(fsdata *mydata, int startsect,
 
 				if (doit) {
 					if (dirc == ' ') {
-						printf(" %8ld   %s%c\n",
-							(long)FAT2CPU32(dentptr->size),
+						printf(" %8u   %s%c\n",
+						       FAT2CPU32(dentptr->size),
 							s_name, dirc);
 					} else {
 						printf("            %s%c\n",
@@ -806,9 +807,8 @@ exit:
 __u8 do_fat_read_at_block[MAX_CLUSTSIZE]
 	__aligned(ARCH_DMA_MINALIGN);
 
-long
-do_fat_read_at(const char *filename, unsigned long pos, void *buffer,
-	       unsigned long maxsize, int dols, int dogetsize)
+int do_fat_read_at(const char *filename, loff_t pos, void *buffer,
+		   loff_t maxsize, int dols, int dogetsize, loff_t *size)
 {
 	char fnamecopy[2048];
 	boot_sector bs;
@@ -821,7 +821,7 @@ do_fat_read_at(const char *filename, unsigned long pos, void *buffer,
 	__u32 cursect;
 	int idx, isdir = 0;
 	int files = 0, dirs = 0;
-	long ret = -1;
+	int ret = -1;
 	int firsttime;
 	__u32 root_cluster = 0;
 	int rootdir_size = 0;
@@ -974,8 +974,8 @@ do_fat_read_at(const char *filename, unsigned long pos, void *buffer,
 						}
 						if (doit) {
 							if (dirc == ' ') {
-								printf(" %8ld   %s%c\n",
-									(long)FAT2CPU32(dentptr->size),
+								printf(" %8u   %s%c\n",
+								       FAT2CPU32(dentptr->size),
 									l_name,
 									dirc);
 							} else {
@@ -1032,8 +1032,8 @@ do_fat_read_at(const char *filename, unsigned long pos, void *buffer,
 				}
 				if (doit) {
 					if (dirc == ' ') {
-						printf(" %8ld   %s%c\n",
-							(long)FAT2CPU32(dentptr->size),
+						printf(" %8u   %s%c\n",
+						       FAT2CPU32(dentptr->size),
 							s_name, dirc);
 					} else {
 						printf("            %s%c\n",
@@ -1102,7 +1102,7 @@ do_fat_read_at(const char *filename, unsigned long pos, void *buffer,
 			if (dols == LS_ROOT) {
 				printf("\n%d file(s), %d dir(s)\n\n",
 				       files, dirs);
-				ret = 0;
+				*size = 0;
 			}
 			goto exit;
 		}
@@ -1141,7 +1141,7 @@ rootdir_done:
 		if (get_dentfromdir(mydata, startsect, subname, dentptr,
 				     isdir ? 0 : dols) == NULL) {
 			if (dols && !isdir)
-				ret = 0;
+				*size = 0;
 			goto exit;
 		}
 
@@ -1152,21 +1152,23 @@ rootdir_done:
 			subname = nextname;
 	}
 
-	if (dogetsize)
-		ret = FAT2CPU32(dentptr->size);
-	else
-		ret = get_contents(mydata, dentptr, pos, buffer, maxsize);
-	debug("Size: %d, got: %ld\n", FAT2CPU32(dentptr->size), ret);
+	if (dogetsize) {
+		*size = FAT2CPU32(dentptr->size);
+		ret = 0;
+	} else {
+		ret = get_contents(mydata, dentptr, pos, buffer, maxsize, size);
+	}
+	debug("Size: %u, got: %llu\n", FAT2CPU32(dentptr->size), *size);
 
 exit:
 	free(mydata->fatbuf);
 	return ret;
 }
 
-long
-do_fat_read(const char *filename, void *buffer, unsigned long maxsize, int dols)
+int do_fat_read(const char *filename, void *buffer, loff_t maxsize, int dols,
+		loff_t *actread)
 {
-	return do_fat_read_at(filename, 0, buffer, maxsize, dols, 0);
+	return do_fat_read_at(filename, 0, buffer, maxsize, dols, 0, actread);
 }
 
 int file_fat_detectfs(void)
@@ -1233,44 +1235,50 @@ int file_fat_detectfs(void)
 
 int file_fat_ls(const char *dir)
 {
-	return do_fat_read(dir, NULL, 0, LS_YES);
+	loff_t size;
+
+	return do_fat_read(dir, NULL, 0, LS_YES, &size);
 }
 
 int fat_exists(const char *filename)
 {
-	int sz;
-	sz = do_fat_read_at(filename, 0, NULL, 0, LS_NO, 1);
-	return sz >= 0;
+	int ret;
+	loff_t size;
+	ret = do_fat_read_at(filename, 0, NULL, 0, LS_NO, 1, &size);
+	return ret == 0;
 }
 
-int fat_size(const char *filename)
+int fat_size(const char *filename, loff_t *size)
 {
-	return do_fat_read_at(filename, 0, NULL, 0, LS_NO, 1);
+	return do_fat_read_at(filename, 0, NULL, 0, LS_NO, 1, size);
 }
 
-long file_fat_read_at(const char *filename, unsigned long pos, void *buffer,
-		      unsigned long maxsize)
+int file_fat_read_at(const char *filename, loff_t pos, void *buffer,
+		     loff_t maxsize, loff_t *actread)
 {
 	printf("reading %s\n", filename);
-	return do_fat_read_at(filename, pos, buffer, maxsize, LS_NO, 0);
+	return do_fat_read_at(filename, pos, buffer, maxsize, LS_NO, 0,
+			      actread);
 }
 
-long file_fat_read(const char *filename, void *buffer, unsigned long maxsize)
+int file_fat_read(const char *filename, void *buffer, loff_t maxsize,
+		  loff_t *actread)
 {
-	return file_fat_read_at(filename, 0, buffer, maxsize);
+	return file_fat_read_at(filename, 0, buffer, maxsize, actread);
 }
 
-int fat_read_file(const char *filename, void *buf, int offset, int len)
+int fat_read_file(const char *filename, void *buf, loff_t offset, loff_t len,
+		  loff_t *actread)
 {
-	int len_read;
+	int ret;
 
-	len_read = file_fat_read_at(filename, offset, buf, len);
-	if (len_read == -1) {
+	ret = file_fat_read_at(filename, offset, buf, len, actread);
+	if (ret < 0) {
 		printf("** Unable to read file %s **\n", filename);
 		return -1;
 	}
 
-	return len_read;
+	return 0;
 }
 
 void fat_close(void)
diff --git a/fs/fat/fat_write.c b/fs/fat/fat_write.c
index 24ed5d3..88dd495 100644
--- a/fs/fat/fat_write.c
+++ b/fs/fat/fat_write.c
@@ -660,24 +660,26 @@ static int clear_fatent(fsdata *mydata, __u32 entry)
 /*
  * Write at most 'maxsize' bytes from 'buffer' into
  * the file associated with 'dentptr'
- * Return the number of bytes read or -1 on fatal errors.
+ * Update the number of bytes written in *gotsize and return 0
+ * or return -1 on fatal errors.
  */
 static int
 set_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer,
-	      unsigned long maxsize)
+	      loff_t maxsize, loff_t *gotsize)
 {
-	unsigned long filesize = FAT2CPU32(dentptr->size), gotsize = 0;
+	loff_t filesize = FAT2CPU32(dentptr->size);
 	unsigned int bytesperclust = mydata->clust_size * mydata->sect_size;
 	__u32 curclust = START(dentptr);
 	__u32 endclust = 0, newclust = 0;
-	unsigned long actsize;
+	loff_t actsize;
 
-	debug("Filesize: %ld bytes\n", filesize);
+	*gotsize = 0;
+	debug("Filesize: %llu bytes\n", filesize);
 
 	if (maxsize > 0 && filesize > maxsize)
 		filesize = maxsize;
 
-	debug("%ld bytes\n", filesize);
+	debug("%llu bytes\n", filesize);
 
 	actsize = bytesperclust;
 	endclust = curclust;
@@ -692,7 +694,7 @@ set_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer,
 			if (CHECK_CLUST(newclust, mydata->fatsize)) {
 				debug("curclust: 0x%x\n", newclust);
 				debug("Invalid FAT entry\n");
-				return gotsize;
+				return 0;
 			}
 			endclust = newclust;
 			actsize += bytesperclust;
@@ -706,7 +708,7 @@ set_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer,
 		}
 
 		/* set remaining bytes */
-		gotsize += (int)actsize;
+		*gotsize += actsize;
 		filesize -= actsize;
 		buffer += actsize;
 		actsize = filesize;
@@ -715,7 +717,7 @@ set_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer,
 			debug("error: writing cluster\n");
 			return -1;
 		}
-		gotsize += actsize;
+		*gotsize += actsize;
 
 		/* Mark end of file in FAT */
 		if (mydata->fatsize == 16)
@@ -724,20 +726,20 @@ set_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer,
 			newclust = 0xfffffff;
 		set_fatent_value(mydata, endclust, newclust);
 
-		return gotsize;
+		return 0;
 getit:
 		if (set_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
 			debug("error: writing cluster\n");
 			return -1;
 		}
-		gotsize += (int)actsize;
+		*gotsize += actsize;
 		filesize -= actsize;
 		buffer += actsize;
 
 		if (CHECK_CLUST(curclust, mydata->fatsize)) {
 			debug("curclust: 0x%x\n", curclust);
 			debug("Invalid FAT entry\n");
-			return gotsize;
+			return 0;
 		}
 		actsize = bytesperclust;
 		curclust = endclust = newclust;
@@ -766,7 +768,7 @@ static void fill_dentry(fsdata *mydata, dir_entry *dentptr,
  * exceed the size of the block device
  * Return -1 when overflow occurs, otherwise return 0
  */
-static int check_overflow(fsdata *mydata, __u32 clustnum, unsigned long size)
+static int check_overflow(fsdata *mydata, __u32 clustnum, loff_t size)
 {
 	__u32 startsect, sect_num;
 
@@ -923,8 +925,8 @@ static dir_entry *find_directory_entry(fsdata *mydata, int startsect,
 	return NULL;
 }
 
-static int do_fat_write(const char *filename, void *buffer,
-	unsigned long size)
+static int do_fat_write(const char *filename, void *buffer, loff_t size,
+			loff_t *actwrite)
 {
 	dir_entry *dentptr, *retdent;
 	__u32 startsect;
@@ -936,8 +938,8 @@ static int do_fat_write(const char *filename, void *buffer,
 	int cursect;
 	int ret = -1, name_len;
 	char l_filename[VFAT_MAXLEN_BYTES];
-	int write_size = size;
 
+	*actwrite = size;
 	dir_curclust = 0;
 
 	if (read_bootsectandvi(&bs, &volinfo, &mydata->fatsize)) {
@@ -1015,7 +1017,7 @@ static int do_fat_write(const char *filename, void *buffer,
 
 		ret = check_overflow(mydata, start_cluster, size);
 		if (ret) {
-			printf("Error: %ld overflow\n", size);
+			printf("Error: %llu overflow\n", size);
 			goto exit;
 		}
 
@@ -1025,13 +1027,12 @@ static int do_fat_write(const char *filename, void *buffer,
 			goto exit;
 		}
 
-		ret = set_contents(mydata, retdent, buffer, size);
+		ret = set_contents(mydata, retdent, buffer, size, actwrite);
 		if (ret < 0) {
 			printf("Error: writing contents\n");
 			goto exit;
 		}
-		write_size = ret;
-		debug("attempt to write 0x%x bytes\n", write_size);
+		debug("attempt to write 0x%llx bytes\n", *actwrite);
 
 		/* Flush fat buffer */
 		ret = flush_fat_buffer(mydata);
@@ -1061,7 +1062,7 @@ static int do_fat_write(const char *filename, void *buffer,
 
 		ret = check_overflow(mydata, start_cluster, size);
 		if (ret) {
-			printf("Error: %ld overflow\n", size);
+			printf("Error: %llu overflow\n", size);
 			goto exit;
 		}
 
@@ -1069,13 +1070,13 @@ static int do_fat_write(const char *filename, void *buffer,
 		fill_dentry(mydata, empty_dentptr, filename,
 			start_cluster, size, 0x20);
 
-		ret = set_contents(mydata, empty_dentptr, buffer, size);
+		ret = set_contents(mydata, empty_dentptr, buffer, size,
+				   actwrite);
 		if (ret < 0) {
 			printf("Error: writing contents\n");
 			goto exit;
 		}
-		write_size = ret;
-		debug("attempt to write 0x%x bytes\n", write_size);
+		debug("attempt to write 0x%llx bytes\n", *actwrite);
 
 		/* Flush fat buffer */
 		ret = flush_fat_buffer(mydata);
@@ -1096,11 +1097,17 @@ static int do_fat_write(const char *filename, void *buffer,
 
 exit:
 	free(mydata->fatbuf);
-	return ret < 0 ? ret : write_size;
+	return ret;
 }
 
-int file_fat_write(const char *filename, void *buffer, unsigned long maxsize)
+int file_fat_write(const char *filename, void *buffer, loff_t offset,
+		   loff_t maxsize, loff_t *actwrite)
 {
+	if (offset != 0) {
+		printf("Error: non zero offset is currently not suported.\n");
+		return -1;
+	}
+
 	printf("writing %s\n", filename);
-	return do_fat_write(filename, buffer, maxsize);
+	return do_fat_write(filename, buffer, maxsize, actwrite);
 }
diff --git a/fs/fat/file.c b/fs/fat/file.c
index d910c46..b608883 100644
--- a/fs/fat/file.c
+++ b/fs/fat/file.c
@@ -162,8 +162,8 @@ file_ls(const char *dir)
 	return filesystems[current_filesystem].ls(arg);
 }
 
-long
-file_read(const char *filename, void *buffer, unsigned long maxsize)
+int
+file_read(const char *filename, void *buffer, loff_t maxsize, loff_t *actread)
 {
 	char fullpath[1024];
 	const char *arg;
@@ -180,5 +180,6 @@ file_read(const char *filename, void *buffer, unsigned long maxsize)
 		arg = fullpath;
 	}
 
-	return filesystems[current_filesystem].read(arg, buffer, maxsize);
+	return filesystems[current_filesystem].read(arg, buffer, maxsize,
+						    actread);
 }
diff --git a/include/fat.h b/include/fat.h
index 20ca3f3..7a57533 100644
--- a/include/fat.h
+++ b/include/fat.h
@@ -178,8 +178,8 @@ typedef struct {
 
 typedef int	(file_detectfs_func)(void);
 typedef int	(file_ls_func)(const char *dir);
-typedef long	(file_read_func)(const char *filename, void *buffer,
-				 unsigned long maxsize);
+typedef int	(file_read_func)(const char *filename, void *buffer,
+				 loff_t maxsize, loff_t *actread);
 
 struct filesystem {
 	file_detectfs_func	*detect;
@@ -198,15 +198,18 @@ int file_cd(const char *path);
 int file_fat_detectfs(void);
 int file_fat_ls(const char *dir);
 int fat_exists(const char *filename);
-int fat_size(const char *filename);
-long file_fat_read_at(const char *filename, unsigned long pos, void *buffer,
-		      unsigned long maxsize);
-long file_fat_read(const char *filename, void *buffer, unsigned long maxsize);
+int fat_size(const char *filename, loff_t *size);
+int file_fat_read_at(const char *filename, loff_t pos, void *buffer,
+		     loff_t maxsize, loff_t *actread);
+int file_fat_read(const char *filename, void *buffer, loff_t maxsize,
+		  loff_t *actread);
 const char *file_getfsname(int idx);
 int fat_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info);
 int fat_register_device(block_dev_desc_t *dev_desc, int part_no);
 
-int file_fat_write(const char *filename, void *buffer, unsigned long maxsize);
-int fat_read_file(const char *filename, void *buf, int offset, int len);
+int file_fat_write(const char *filename, void *buf, loff_t offset, loff_t len,
+		   loff_t *actwrite);
+int fat_read_file(const char *filename, void *buf, loff_t offset, loff_t len,
+		  loff_t *actread);
 void fat_close(void);
 #endif /* _FAT_H_ */
-- 
1.9.1



More information about the U-Boot mailing list