sandbox: Add filesystem support

996 lines not on this page · raw message

974 lines not on this page · raw message

index 2c9f2c5..66835e2 100644
@@ -27,6 +27,12 @@ static block_dev_desc_t *fs_dev_desc;
 static disk_partition_t fs_partition;
 static int fs_type = FS_TYPE_ANY;
 
+static inline int fs_probe_unsupported(void)
+{
+	printf("** Unrecognized filesystem type **\n");
+	return -1;
+}
+
 static inline int fs_ls_unsupported(const char *dirname)
 {
 	printf("** Unrecognized filesystem type **\n");

@@ -40,6 +46,10 @@ static inline int fs_read_unsupported(const char *filename, ulong addr,
 	return -1;
 }
 
+static inline void fs_close_unsupported(void)
+{
+}
+
 #ifdef CONFIG_FS_FAT
 static int fs_probe_fat(void)
 {

@@ -143,29 +153,57 @@ static inline void fs_close_ext(void)
 #define fs_read_ext fs_read_unsupported
 #endif
 
-static struct {
+struct fstype_info {
 	int fstype;
 	int (*probe)(void);
-} fstypes[] = {
+	int (*ls)(const char *dirname);
+	int (*read)(const char *filename, ulong addr, int offset, int len);
+	void (*close)(void);
+};
+
+static struct fstype_info fstypes[] = {
+#ifdef CONFIG_FS_FAT
 	{
 		.fstype = FS_TYPE_FAT,
 		.probe = fs_probe_fat,
+		.close = fs_close_fat,
+		.ls = file_fat_ls,
+		.read = fs_read_fat,
 	},
+#endif
+#ifdef CONFIG_FS_EXT4
 	{
 		.fstype = FS_TYPE_EXT,
 		.probe = fs_probe_ext,
+		.close = fs_close_ext,
+		.ls = ext4fs_ls,
+		.read = fs_read_ext,
+	},
+#endif
+	{
+		.fstype = FS_TYPE_ANY,
+		.probe = fs_probe_unsupported,
+		.close = fs_close_unsupported,
+		.ls = fs_ls_unsupported,
+		.read = fs_read_unsupported,
 	},
 };
 
 int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype)
 {
+	struct fstype_info *info;
 	int part, i;
 #ifdef CONFIG_NEEDS_MANUAL_RELOC
 	static int relocated;
 
 	if (!relocated) {
-		for (i = 0; i < ARRAY_SIZE(fstypes); i++)
-			fstypes[i].probe += gd->reloc_off;
+		for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes);
+				i++, info++) {
+			info->probe += gd->reloc_off;
+			info->close += gd->reloc_off;
+			info->ls += gd->reloc_off;
+			info->read += gd->reloc_off;
+		}
 		relocated = 1;
 	}
 #endif

@@ -175,17 +213,17 @@ int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype)
 	if (part < 0)
 		return -1;
 
-	for (i = 0; i < ARRAY_SIZE(fstypes); i++) {
-		if ((fstype != FS_TYPE_ANY) && (fstype != fstypes[i].fstype))
+	for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes); i++, info++) {
+		if (fstype != FS_TYPE_ANY && info->fstype != FS_TYPE_ANY &&
+				fstype != info->fstype)
 			continue;
 
-		if (!fstypes[i].probe()) {
-			fs_type = fstypes[i].fstype;
+		if (!info->probe()) {
+			fs_type = info->fstype;
 			return 0;
 		}
 	}
 
-	printf("** Unrecognized filesystem type **\n");
 	return -1;
 }
 

index 66835e2..856d8ba 100644
@@ -35,14 +35,12 @@ static inline int fs_probe_unsupported(void)
 
 static inline int fs_ls_unsupported(const char *dirname)
 {
-	printf("** Unrecognized filesystem type **\n");
 	return -1;
 }
 
 static inline int fs_read_unsupported(const char *filename, ulong addr,
 				      int offset, int len)
 {
-	printf("** Unrecognized filesystem type **\n");
 	return -1;
 }
 

@@ -189,6 +187,20 @@ static struct fstype_info fstypes[] = {
 	},
 };
 
+static struct fstype_info *fs_get_info(int fstype)
+{
+	struct fstype_info *info;
+	int i;
+
+	for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes) - 1; i++, info++) {
+		if (fstype == info->fstype)
+			return info;
+	}
+
+	/* Return the 'unsupported' sentinel */
+	return info;
+}
+
 int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype)
 {
 	struct fstype_info *info;

@@ -229,17 +241,9 @@ int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype)
 
 static void fs_close(void)
 {
-	switch (fs_type) {
-	case FS_TYPE_FAT:
-		fs_close_fat();
-		break;
-	case FS_TYPE_EXT:
-		fs_close_ext();
-		break;
-	default:
-		break;
-	}
+	struct fstype_info *info = fs_get_info(fs_type);
 
+	info->close();
 	fs_type = FS_TYPE_ANY;
 }
 

@@ -247,17 +251,9 @@ int fs_ls(const char *dirname)
 {
 	int ret;
 
-	switch (fs_type) {
-	case FS_TYPE_FAT:
-		ret = fs_ls_fat(dirname);
-		break;
-	case FS_TYPE_EXT:
-		ret = fs_ls_ext(dirname);
-		break;
-	default:
-		ret = fs_ls_unsupported(dirname);
-		break;
-	}
+	struct fstype_info *info = fs_get_info(fs_type);
+
+	ret = info->ls(dirname);
 
 	fs_close();
 

@@ -266,20 +262,16 @@ int fs_ls(const char *dirname)
 
 int fs_read(const char *filename, ulong addr, int offset, int len)
 {
+	struct fstype_info *info = fs_get_info(fs_type);
 	int ret;
 
-	switch (fs_type) {
-	case FS_TYPE_FAT:
-		ret = fs_read_fat(filename, addr, offset, len);
-		break;
-	case FS_TYPE_EXT:
-		ret = fs_read_ext(filename, addr, offset, len);
-		break;
-	default:
-		ret = fs_read_unsupported(filename, addr, offset, len);
-		break;
-	}
+	ret = info->read(filename, addr, offset, len);
 
+	/* If we requested a specific number of bytes, check we got it */
+	if (ret >= 0 && len && ret != len) {
+		printf("** Unable to read file %s **\n", filename);
+		ret = -1;
+	}
 	fs_close();
 
 	return ret;

index 856d8ba..3561727 100644
@@ -27,7 +27,8 @@ static block_dev_desc_t *fs_dev_desc;
 static disk_partition_t fs_partition;
 static int fs_type = FS_TYPE_ANY;
 
-static inline int fs_probe_unsupported(void)
+static inline int fs_probe_unsupported(block_dev_desc_t *fs_dev_desc,
+				      disk_partition_t *fs_partition)
 {
 	printf("** Unrecognized filesystem type **\n");
 	return -1;

@@ -49,9 +50,10 @@ static inline void fs_close_unsupported(void)
 }
 
 #ifdef CONFIG_FS_FAT
-static int fs_probe_fat(void)
+static int fs_probe_fat(block_dev_desc_t *fs_dev_desc,
+			disk_partition_t *fs_partition)
 {
-	return fat_set_blk_dev(fs_dev_desc, &fs_partition);
+	return fat_set_blk_dev(fs_dev_desc, fs_partition);
 }
 
 static void fs_close_fat(void)

@@ -88,11 +90,12 @@ static inline void fs_close_fat(void)
 #endif
 
 #ifdef CONFIG_FS_EXT4
-static int fs_probe_ext(void)
+static int fs_probe_ext(block_dev_desc_t *fs_dev_desc,
+			disk_partition_t *fs_partition)
 {
-	ext4fs_set_blk_dev(fs_dev_desc, &fs_partition);
+	ext4fs_set_blk_dev(fs_dev_desc, fs_partition);
 
-	if (!ext4fs_mount(fs_partition.size)) {
+	if (!ext4fs_mount(fs_partition->size)) {
 		ext4fs_close();
 		return -1;
 	}

@@ -153,7 +156,8 @@ static inline void fs_close_ext(void)
 
 struct fstype_info {
 	int fstype;
-	int (*probe)(void);
+	int (*probe)(block_dev_desc_t *fs_dev_desc,
+		     disk_partition_t *fs_partition);
 	int (*ls)(const char *dirname);
 	int (*read)(const char *filename, ulong addr, int offset, int len);
 	void (*close)(void);

@@ -230,7 +234,7 @@ int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype)
 				fstype != info->fstype)
 			continue;
 
-		if (!info->probe()) {
+		if (!info->probe(fs_dev_desc, &fs_partition)) {
 			fs_type = info->fstype;
 			return 0;
 		}

index 3561727..0cbec99 100644
@@ -20,6 +20,7 @@
 #include <ext4fs.h>
 #include <fat.h>
 #include <fs.h>
+#include <asm/io.h>
 
 DECLARE_GLOBAL_DATA_PTR;
 

@@ -39,7 +40,7 @@ static inline int fs_ls_unsupported(const char *dirname)
 	return -1;
 }
 
-static inline int fs_read_unsupported(const char *filename, ulong addr,
+static inline int fs_read_unsupported(const char *filename, void *buf,
 				      int offset, int len)
 {
 	return -1;

@@ -62,12 +63,11 @@ static void fs_close_fat(void)
 
 #define fs_ls_fat file_fat_ls
 
-static int fs_read_fat(const char *filename, ulong addr, int offset, int len)
+static int fs_read_fat(const char *filename, void *buf, int offset, int len)
 {
 	int len_read;
 
-	len_read = file_fat_read_at(filename, offset,
-				    (unsigned char *)addr, len);
+	len_read = file_fat_read_at(filename, offset, buf, len);
 	if (len_read == -1) {
 		printf("** Unable to read file %s **\n", filename);
 		return -1;

@@ -110,7 +110,7 @@ static void fs_close_ext(void)
 
 #define fs_ls_ext ext4fs_ls
 
-static int fs_read_ext(const char *filename, ulong addr, int offset, int len)
+static int fs_read_ext(const char *filename, void *buf, int offset, int len)
 {
 	int file_len;
 	int len_read;

@@ -130,7 +130,7 @@ static int fs_read_ext(const char *filename, ulong addr, int offset, int len)
 	if (len == 0)
 		len = file_len;
 
-	len_read = ext4fs_read((char *)addr, len);
+	len_read = ext4fs_read(buf, len);
 	ext4fs_close();
 
 	if (len_read != len) {

@@ -159,7 +159,7 @@ struct fstype_info {
 	int (*probe)(block_dev_desc_t *fs_dev_desc,
 		     disk_partition_t *fs_partition);
 	int (*ls)(const char *dirname);
-	int (*read)(const char *filename, ulong addr, int offset, int len);
+	int (*read)(const char *filename, void *buf, int offset, int len);
 	void (*close)(void);
 };
 

@@ -267,9 +267,16 @@ int fs_ls(const char *dirname)
 int fs_read(const char *filename, ulong addr, int offset, int len)
 {
 	struct fstype_info *info = fs_get_info(fs_type);
+	void *buf;
 	int ret;
 
-	ret = info->read(filename, addr, offset, len);
+	/*
+	 * We don't actually know how many bytes are being read, since len==0
+	 * means read the whole file.
+	 */
+	buf = map_sysmem(addr, len);
+	ret = info->read(filename, buf, offset, len);
+	unmap_sysmem(buf);
 
 	/* If we requested a specific number of bytes, check we got it */
 	if (ret >= 0 && len && ret != len) {

index 7fdb463..4dddde2 100644
@@ -191,3 +191,40 @@ int ext4fs_read(char *buf, unsigned len)
 
 	return ext4fs_read_file(ext4fs_file, 0, len, buf);
 }
+
+int ext4fs_probe(block_dev_desc_t *fs_dev_desc,
+		 disk_partition_t *fs_partition)
+{
+	ext4fs_set_blk_dev(fs_dev_desc, fs_partition);
+
+	if (!ext4fs_mount(fs_partition->size)) {
+		ext4fs_close();
+		return -1;
+	}
+
+	return 0;
+}
+
+int ext4_read_file(const char *filename, void *buf, int offset, int len)
+{
+	int file_len;
+	int len_read;
+
+	if (offset != 0) {
+		printf("** Cannot support non-zero offset **\n");
+		return -1;
+	}
+
+	file_len = ext4fs_open(filename);
+	if (file_len < 0) {
+		printf("** File not found %s **\n", filename);
+		return -1;
+	}
+
+	if (len == 0)
+		len = file_len;
+
+	len_read = ext4fs_read(buf, len);
+
+	return len_read;
+}

index 393c378..82135b5 100644
@@ -1256,3 +1256,20 @@ long file_fat_read(const char *filename, void *buffer, unsigned long maxsize)
 {
 	return file_fat_read_at(filename, 0, buffer, maxsize);
 }
+
+int fat_read_file(const char *filename, void *buf, int offset, int len)
+{
+	int len_read;
+
+	len_read = file_fat_read_at(filename, offset, buf, len);
+	if (len_read == -1) {
+		printf("** Unable to read file %s **\n", filename);
+		return -1;
+	}
+
+	return len_read;
+}
+
+void fat_close(void)
+{
+}

149 lines not on this page · raw message

index 3b59d15..025a2e8 100644
@@ -138,4 +138,7 @@ void ext4fs_free_node(struct ext2fs_node *node, struct ext2fs_node *currroot);
 int ext4fs_devread(int sector, int byte_offset, int byte_len, char *buf);
 void ext4fs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info);
 long int read_allocated_block(struct ext2_inode *inode, int fileblock);
+int ext4fs_probe(block_dev_desc_t *fs_dev_desc,
+		 disk_partition_t *fs_partition);
+int ext4_read_file(const char *filename, void *buf, int offset, int len);
 #endif

index 706cd7a..0b9017e 100644
@@ -216,4 +216,6 @@ 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);
+void fat_close(void);
 #endif /* _FAT_H_ */

index 3e37c93..d075407 100644
@@ -19,10 +19,13 @@
  * MA 02111-1307 USA
  */
 
+#include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <getopt.h>
+#include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <termios.h>
 #include <time.h>
 #include <unistd.h>

@@ -261,3 +264,101 @@ int os_parse_args(struct sandbox_state *state, int argc, char *argv[])
 
 	return 0;
 }
+
+void os_dirent_free(struct os_dirent_node *node)
+{
+	struct os_dirent_node *next;
+
+	while (node) {
+		next = node->next;
+		free(node);
+		node = next;
+	}
+}
+
+int os_dirent_ls(const char *dirname, struct os_dirent_node **headp)
+{
+	struct dirent entry, *result;
+	struct os_dirent_node *head, *node, *next;
+	struct stat buf;
+	DIR *dir;
+	int ret;
+	char *fname;
+	int len;
+
+	*headp = NULL;
+	dir = opendir(dirname);
+	if (!dir)
+		return -1;
+
+	/* Create a buffer for the maximum filename length */
+	len = sizeof(entry.d_name) + strlen(dirname) + 2;
+	fname = malloc(len);
+	if (!fname) {
+		ret = -ENOMEM;
+		goto done;
+	}
+
+	for (node = head = NULL;; node = next) {
+		ret = readdir_r(dir, &entry, &result);
+		if (ret || !result)
+			break;
+		next = malloc(sizeof(*node) + strlen(entry.d_name) + 1);
+		if (!next) {
+			os_dirent_free(head);
+			ret = -ENOMEM;
+			goto done;
+		}
+		strcpy(next->name, entry.d_name);
+		switch (entry.d_type) {
+		case DT_REG:
+			next->type = OS_FILET_REG;
+			break;
+		case DT_DIR:
+			next->type = OS_FILET_DIR;
+			break;
+		case DT_LNK:
+			next->type = OS_FILET_LNK;
+			break;
+		}
+		next->size = 0;
+		snprintf(fname, len, "%s/%s", dirname, next->name);
+		if (!stat(fname, &buf))
+			next->size = buf.st_size;
+		if (node)
+			node->next = next;
+		if (!head)
+			head = node;
+	}
+	*headp = head;
+
+done:
+	closedir(dir);
+	return ret;
+}
+
+const char *os_dirent_typename[OS_FILET_COUNT] = {
+	"   ",
+	"SYM",
+	"DIR",
+	"???",
+};
+
+const char *os_dirent_get_typename(enum os_dirent_t type)
+{
+	if (type >= 0 && type < OS_FILET_COUNT)
+		return os_dirent_typename[type];
+
+	return os_dirent_typename[OS_FILET_UNKNOWN];
+}
+
+ssize_t os_get_filesize(const char *fname)
+{
+	struct stat buf;
+	int ret;
+
+	ret = stat(fname, &buf);
+	if (ret)
+		return ret;
+	return buf.st_size;
+}

52 lines not on this page · raw message

index 7bdc90e..58a4563 100644
@@ -472,6 +472,23 @@ int get_device_and_partition(const char *ifname, const char *dev_part_str,
 	int part;
 	disk_partition_t tmpinfo;
 
+	/*
+	 * For now, we have a special case for sandbox, since there is no
+	 * real block device support.
+	 */
+	if (0 == strcmp(ifname, "host")) {
+		*dev_desc = NULL;
+		info->start = info->size =  info->blksz = 0;
+		info->bootable = 0;
+		strcpy((char *)info->type, BOOT_PART_TYPE);
+		strcpy((char *)info->name, "Sandbox host");
+#ifdef CONFIG_PARTITION_UUIDS
+		info->uuid[0] = 0;
+#endif
+
+		return 0;
+	}
+
 	/* If no dev_part_str, use bootdevice environment variable */
 	if (!dev_part_str || !strlen(dev_part_str) ||
 	    !strcmp(dev_part_str, "-"))

index 95c882e..6f5063c 100644
@@ -20,6 +20,7 @@
 #include <ext4fs.h>
 #include <fat.h>
 #include <fs.h>
+#include <sandboxfs.h>
 #include <asm/io.h>
 
 DECLARE_GLOBAL_DATA_PTR;

@@ -78,6 +79,15 @@ static struct fstype_info fstypes[] = {
 		.read = ext4_read_file,
 	},
 #endif
+#ifdef CONFIG_SANDBOX
+	{
+		.fstype = FS_TYPE_SANDBOX,
+		.probe = sandbox_fs_set_blk_dev,
+		.close = sandbox_fs_close,
+		.ls = sandbox_fs_ls,
+		.read = fs_read_sandbox,
+	},
+#endif
 	{
 		.fstype = FS_TYPE_ANY,
 		.probe = fs_probe_unsupported,

83 lines not on this page · raw message

index 4f30a38..b6d69e5 100644
@@ -21,6 +21,7 @@
 #define FS_TYPE_ANY	0
 #define FS_TYPE_FAT	1
 #define FS_TYPE_EXT	2
+#define FS_TYPE_SANDBOX	3
 
 /*
  * Tell the fs layer which block device an partition to use for future

new file mode 100644
index 0000000..f5213ac
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2012, Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __SANDBOX_FS__
+#define __SANDBOX_FS__
+
+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);
+
+void sandbox_fs_close(void);
+int sandbox_fs_ls(const char *dirname);
+int fs_read_sandbox(const char *filename, void *buf, int offset, int len);
+
+#endif

63 lines not on this page · raw message

index e82f642..61c302e 100644
@@ -75,6 +75,7 @@
 #define CONFIG_CMD_RARP		/* rarpboot support		*/
 #define CONFIG_CMD_READ		/* Read data from partition	*/
 #define CONFIG_CMD_RUN		/* run command in env variable	*/
+#define CONFIG_CMD_SANDBOX	/* sb command to access sandbox features */
 #define CONFIG_CMD_SAVEENV	/* saveenv			*/
 #define CONFIG_CMD_SAVES	/* save S record dump		*/
 #define CONFIG_CMD_SCSI		/* SCSI Support			*/

index 9f51a0b..2a45c7b 100644
@@ -32,6 +32,13 @@
 #define CONFIG_OF_LIBFDT
 #define CONFIG_LMB
 
+#define CONFIG_FS_FAT
+#define CONFIG_FS_EXT4
+#define CONFIG_EXT4_WRITE
+#define CONFIG_CMD_FAT
+#define CONFIG_CMD_EXT4
+#define CONFIG_CMD_EXT4_WRITE
+
 #define CONFIG_SYS_VSNPRINTF
 
 #define CONFIG_CMD_GPIO

index 2a45c7b..406da43 100644
@@ -97,6 +97,8 @@
 #define CONFIG_SHA1
 #define CONFIG_SHA256
 
+#define CONFIG_CMD_SANDBOX
+
 #define CONFIG_BOOTARGS ""
 
 #define CONFIG_EXTRA_ENV_SETTINGS	"stdin=serial\0" \