sandbox: Prepare API change for files greater than 2GB

Change the internal sandbox functions to use loff_t for file offsets. Signed-off-by: Suriyan Ramasami <suriyan.r@gmail.com> Acked-by: Simon Glass <sjg@chromium.org>

sandbox: Prepare API change for files greater than 2GB
Change the internal sandbox functions to use loff_t for file offsets. Signed-off-by: Suriyan Ramasami <suriyan.r@gmail.com> Acked-by: Simon Glass <sjg@chromium.org>
Suriyan Ramasami · Tom Rini
1 parent 9f12cd0e06
Showing 6 changed files with 77 additions and 41 deletions Side-by-side Diff
arch/sandbox/cpu/os.c
arch/sandbox/cpu/state.c
common/board_f.c
fs/sandbox/sandboxfs.c
include/os.h
include/sandboxfs.h
@@ -385,7 +385,7 @@
 	return os_dirent_typename[OS_FILET_UNKNOWN];
 }
  
-ssize_t os_get_filesize(const char *fname)
+int os_get_filesize(const char *fname, loff_t *size)
 {
 	struct stat buf;
 	int ret;
@@ -393,7 +393,8 @@
 	ret = stat(fname, &buf);
 	if (ret)
 		return ret;
-	return buf.st_size;
+	*size = buf.st_size;
+	return 0;
 }
  
 void os_putc(int ch)
  
@@ -427,11 +428,11 @@
 {
 	struct sandbox_state *state = state_get_current();
 	int fd, ret;
-	int size;
+	loff_t size;
  
-	size = os_get_filesize(fname);
-	if (size < 0)
-		return -ENOENT;
+	ret = os_get_filesize(fname, &size);
+	if (ret < 0)
+		return ret;
 	if (size != state->ram_size)
 		return -ENOSPC;
 	fd = open(fname, O_RDONLY);
@@ -49,14 +49,14 @@
  
 static int state_read_file(struct sandbox_state *state, const char *fname)
 {
-	int size;
+	loff_t size;
 	int ret;
 	int fd;
  
-	size = os_get_filesize(fname);
-	if (size < 0) {
+	ret = os_get_filesize(fname, &size);
+	if (ret < 0) {
 		printf("Cannot find sandbox state file '%s'\n", fname);
-		return -ENOENT;
+		return ret;
 	}
 	state->state_fdt = os_malloc(size);
 	if (!state->state_fdt) {
@@ -287,7 +287,7 @@
 	struct sandbox_state *state = state_get_current();
 	const char *fname = state->fdt_fname;
 	void *blob;
-	ssize_t size;
+	loff_t size;
 	int err;
 	int fd;
  
  
@@ -300,10 +300,10 @@
 		return -EINVAL;
 	}
  
-	size = os_get_filesize(fname);
-	if (size < 0) {
+	err = os_get_filesize(fname, &size);
+	if (err < 0) {
 		printf("Failed to file FDT file '%s'\n", fname);
-		return -ENOENT;
+		return err;
 	}
 	fd = os_open(fname, OS_O_RDONLY);
 	if (fd < 0) {
@@ -13,10 +13,10 @@
 	return 0;
 }
  
-long sandbox_fs_read_at(const char *filename, unsigned long pos,
-			     void *buffer, unsigned long maxsize)
+int sandbox_fs_read_at(const char *filename, loff_t pos, void *buffer,
+		       loff_t maxsize, loff_t *actread)
 {
-	ssize_t size;
+	loff_t size;
 	int fd, ret;
  
 	fd = os_open(filename, OS_O_RDONLY);
  
  
@@ -27,16 +27,31 @@
 		os_close(fd);
 		return ret;
 	}
-	if (!maxsize)
-		maxsize = os_get_filesize(filename);
+	if (!maxsize) {
+		ret = os_get_filesize(filename, &size);
+		if (ret) {
+			os_close(fd);
+			return ret;
+		}
+
+		maxsize = size;
+	}
+
 	size = os_read(fd, buffer, maxsize);
 	os_close(fd);
  
-	return size;
+	if (size < 0) {
+		ret = -1;
+	} else {
+		ret = 0;
+		*actread = size;
+	}
+
+	return ret;
 }
  
-long sandbox_fs_write_at(const char *filename, unsigned long pos,
-			 void *buffer, unsigned long towrite)
+int sandbox_fs_write_at(const char *filename, loff_t pos, void *buffer,
+			loff_t towrite, loff_t *actwrite)
 {
 	ssize_t size;
 	int fd, ret;
@@ -52,7 +67,14 @@
 	size = os_write(fd, buffer, towrite);
 	os_close(fd);
  
-	return size;
+	if (size == -1) {
+		ret = -1;
+	} else {
+		ret = 0;
+		*actwrite = size;
+	}
+
+	return ret;
 }
  
 int sandbox_fs_ls(const char *dirname)
  
  
@@ -74,15 +96,23 @@
  
 int sandbox_fs_exists(const char *filename)
 {
-	ssize_t sz;
+	loff_t size;
+	int ret;
  
-	sz = os_get_filesize(filename);
-	return sz >= 0;
+	ret = os_get_filesize(filename, &size);
+	return ret == 0;
 }
  
 int sandbox_fs_size(const char *filename)
 {
-	return os_get_filesize(filename);
+	loff_t size;
+	int ret;
+
+	ret = os_get_filesize(filename, &size);
+	if (ret)
+		return ret;
+	else
+		return size;
 }
  
 void sandbox_fs_close(void)
  
  
  
  
  
  
  
@@ -91,27 +121,29 @@
  
 int fs_read_sandbox(const char *filename, void *buf, int offset, int len)
 {
-	int len_read;
+	int ret;
+	loff_t actread;
  
-	len_read = sandbox_fs_read_at(filename, offset, buf, len);
-	if (len_read == -1) {
+	ret = sandbox_fs_read_at(filename, offset, buf, len, &actread);
+	if (ret) {
 		printf("** Unable to read file %s **\n", filename);
-		return -1;
+		return ret;
 	}
  
-	return len_read;
+	return actread;
 }
  
 int fs_write_sandbox(const char *filename, void *buf, int offset, int len)
 {
-	int len_written;
+	int ret;
+	loff_t actwrite;
  
-	len_written = sandbox_fs_write_at(filename, offset, buf, len);
-	if (len_written == -1) {
+	ret = sandbox_fs_write_at(filename, offset, buf, len, &actwrite);
+	if (ret) {
 		printf("** Unable to write file %s **\n", filename);
-		return -1;
+		return ret;
 	}
  
-	return len_written;
+	return actwrite;
 }
@@ -217,9 +217,10 @@
  * Get the size of a file
  *
  * @param fname		Filename to check
- * @return size of file, or -1 if an error ocurred
+ * @param size		size of file is returned if no error
+ * @return 0 on success or -1 if an error ocurred
  */
-ssize_t os_get_filesize(const char *fname);
+int os_get_filesize(const char *fname, loff_t *size);
  
 /**
  * Write a character to the controlling OS terminal
@@ -20,8 +20,10 @@
  
 int sandbox_fs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info);
  
-long sandbox_fs_read_at(const char *filename, unsigned long pos,
-			     void *buffer, unsigned long maxsize);
+int sandbox_fs_read_at(const char *filename, loff_t pos, void *buffer,
+		       loff_t maxsize, loff_t *actread);
+int sandbox_fs_write_at(const char *filename, loff_t pos, void *buffer,
+			loff_t maxsize, loff_t *actwrite);
  
 void sandbox_fs_close(void);
 int sandbox_fs_ls(const char *dirname);
...	...	@@ -385,7 +385,7 @@
385	385	return os_dirent_typename[OS_FILET_UNKNOWN];
386	386	}
387	387
388		-ssize_t os_get_filesize(const char *fname)
	388	+int os_get_filesize(const char fname, loff_t size)
389	389	{
390	390	struct stat buf;
391	391	int ret;
...	...	@@ -393,7 +393,8 @@
393	393	ret = stat(fname, &buf);
394	394	if (ret)
395	395	return ret;
396		- return buf.st_size;
	396	+ *size = buf.st_size;
	397	+ return 0;
397	398	}
398	399
399	400	void os_putc(int ch)
400	401
...	...	@@ -427,11 +428,11 @@
427	428	{
428	429	struct sandbox_state *state = state_get_current();
429	430	int fd, ret;
430		- int size;
	431	+ loff_t size;
431	432
432		- size = os_get_filesize(fname);
433		- if (size < 0)
434		- return -ENOENT;
	433	+ ret = os_get_filesize(fname, &size);
	434	+ if (ret < 0)
	435	+ return ret;
435	436	if (size != state->ram_size)
436	437	return -ENOSPC;
437	438	fd = open(fname, O_RDONLY);
...	...	@@ -49,14 +49,14 @@
49	49
50	50	static int state_read_file(struct sandbox_state state, const char fname)
51	51	{
52		- int size;
	52	+ loff_t size;
53	53	int ret;
54	54	int fd;
55	55
56		- size = os_get_filesize(fname);
57		- if (size < 0) {
	56	+ ret = os_get_filesize(fname, &size);
	57	+ if (ret < 0) {
58	58	printf("Cannot find sandbox state file '%s'\n", fname);
59		- return -ENOENT;
	59	+ return ret;
60	60	}
61	61	state->state_fdt = os_malloc(size);
62	62	if (!state->state_fdt) {
...	...	@@ -287,7 +287,7 @@
287	287	struct sandbox_state *state = state_get_current();
288	288	const char *fname = state->fdt_fname;
289	289	void *blob;
290		- ssize_t size;
	290	+ loff_t size;
291	291	int err;
292	292	int fd;
293	293
294	294
...	...	@@ -300,10 +300,10 @@
300	300	return -EINVAL;
301	301	}
302	302
303		- size = os_get_filesize(fname);
304		- if (size < 0) {
	303	+ err = os_get_filesize(fname, &size);
	304	+ if (err < 0) {
305	305	printf("Failed to file FDT file '%s'\n", fname);
306		- return -ENOENT;
	306	+ return err;
307	307	}
308	308	fd = os_open(fname, OS_O_RDONLY);
309	309	if (fd < 0) {
...	...	@@ -13,10 +13,10 @@
13	13	return 0;
14	14	}
15	15
16		-long sandbox_fs_read_at(const char *filename, unsigned long pos,
17		- void *buffer, unsigned long maxsize)
	16	+int sandbox_fs_read_at(const char filename, loff_t pos, void buffer,
	17	+ loff_t maxsize, loff_t *actread)
18	18	{
19		- ssize_t size;
	19	+ loff_t size;
20	20	int fd, ret;
21	21
22	22	fd = os_open(filename, OS_O_RDONLY);
23	23
24	24
...	...	@@ -27,16 +27,31 @@
27	27	os_close(fd);
28	28	return ret;
29	29	}
30		- if (!maxsize)
31		- maxsize = os_get_filesize(filename);
	30	+ if (!maxsize) {
	31	+ ret = os_get_filesize(filename, &size);
	32	+ if (ret) {
	33	+ os_close(fd);
	34	+ return ret;
	35	+ }
	36	+
	37	+ maxsize = size;
	38	+ }
	39	+
32	40	size = os_read(fd, buffer, maxsize);
33	41	os_close(fd);
34	42
35		- return size;
	43	+ if (size < 0) {
	44	+ ret = -1;
	45	+ } else {
	46	+ ret = 0;
	47	+ *actread = size;
	48	+ }
	49	+
	50	+ return ret;
36	51	}
37	52
38		-long sandbox_fs_write_at(const char *filename, unsigned long pos,
39		- void *buffer, unsigned long towrite)
	53	+int sandbox_fs_write_at(const char filename, loff_t pos, void buffer,
	54	+ loff_t towrite, loff_t *actwrite)
40	55	{
41	56	ssize_t size;
42	57	int fd, ret;
...	...	@@ -52,7 +67,14 @@
52	67	size = os_write(fd, buffer, towrite);
53	68	os_close(fd);
54	69
55		- return size;
	70	+ if (size == -1) {
	71	+ ret = -1;
	72	+ } else {
	73	+ ret = 0;
	74	+ *actwrite = size;
	75	+ }
	76	+
	77	+ return ret;
56	78	}
57	79
58	80	int sandbox_fs_ls(const char *dirname)
59	81
60	82
...	...	@@ -74,15 +96,23 @@
74	96
75	97	int sandbox_fs_exists(const char *filename)
76	98	{
77		- ssize_t sz;
	99	+ loff_t size;
	100	+ int ret;
78	101
79		- sz = os_get_filesize(filename);
80		- return sz >= 0;
	102	+ ret = os_get_filesize(filename, &size);
	103	+ return ret == 0;
81	104	}
82	105
83	106	int sandbox_fs_size(const char *filename)
84	107	{
85		- return os_get_filesize(filename);
	108	+ loff_t size;
	109	+ int ret;
	110	+
	111	+ ret = os_get_filesize(filename, &size);
	112	+ if (ret)
	113	+ return ret;
	114	+ else
	115	+ return size;
86	116	}
87	117
88	118	void sandbox_fs_close(void)
89	119
90	120
91	121
92	122
93	123
94	124
95	125
...	...	@@ -91,27 +121,29 @@
91	121
92	122	int fs_read_sandbox(const char filename, void buf, int offset, int len)
93	123	{
94		- int len_read;
	124	+ int ret;
	125	+ loff_t actread;
95	126
96		- len_read = sandbox_fs_read_at(filename, offset, buf, len);
97		- if (len_read == -1) {
	127	+ ret = sandbox_fs_read_at(filename, offset, buf, len, &actread);
	128	+ if (ret) {
98	129	printf(" Unable to read file %s \n", filename);
99		- return -1;
	130	+ return ret;
100	131	}
101	132
102		- return len_read;
	133	+ return actread;
103	134	}
104	135
105	136	int fs_write_sandbox(const char filename, void buf, int offset, int len)
106	137	{
107		- int len_written;
	138	+ int ret;
	139	+ loff_t actwrite;
108	140
109		- len_written = sandbox_fs_write_at(filename, offset, buf, len);
110		- if (len_written == -1) {
	141	+ ret = sandbox_fs_write_at(filename, offset, buf, len, &actwrite);
	142	+ if (ret) {
111	143	printf(" Unable to write file %s \n", filename);
112		- return -1;
	144	+ return ret;
113	145	}
114	146
115		- return len_written;
	147	+ return actwrite;
116	148	}
...	...	@@ -217,9 +217,10 @@
217	217	* Get the size of a file
218	218	*
219	219	* @param fname Filename to check
220		- * @return size of file, or -1 if an error ocurred
	220	+ * @param size size of file is returned if no error
	221	+ * @return 0 on success or -1 if an error ocurred
221	222	*/
222		-ssize_t os_get_filesize(const char *fname);
	223	+int os_get_filesize(const char fname, loff_t size);
223	224
224	225	/**
225	226	* Write a character to the controlling OS terminal
...	...	@@ -20,8 +20,10 @@
20	20
21	21	int sandbox_fs_set_blk_dev(block_dev_desc_t rbdd, disk_partition_t info);
22	22
23		-long sandbox_fs_read_at(const char *filename, unsigned long pos,
24		- void *buffer, unsigned long maxsize);
	23	+int sandbox_fs_read_at(const char filename, loff_t pos, void buffer,
	24	+ loff_t maxsize, loff_t *actread);
	25	+int sandbox_fs_write_at(const char filename, loff_t pos, void buffer,
	26	+ loff_t maxsize, loff_t *actwrite);
25	27
26	28	void sandbox_fs_close(void);
27	29	int sandbox_fs_ls(const char *dirname);