* Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved.
*/
+#define LOG_CATEGORY LOGC_CORE
+
+#include <command.h>
#include <config.h>
#include <errno.h>
#include <common.h>
+#include <env.h>
+#include <lmb.h>
+#include <log.h>
#include <mapmem.h>
#include <part.h>
#include <ext4fs.h>
#include <sandboxfs.h>
#include <ubifs_uboot.h>
#include <btrfs.h>
+#include <asm/global_data.h>
#include <asm/io.h>
#include <div64.h>
#include <linux/math64.h>
+#include <efi_loader.h>
+#include <squashfs.h>
DECLARE_GLOBAL_DATA_PTR;
static struct blk_desc *fs_dev_desc;
static int fs_dev_part;
-static disk_partition_t fs_partition;
+static struct disk_partition fs_partition;
static int fs_type = FS_TYPE_ANY;
static inline int fs_probe_unsupported(struct blk_desc *fs_dev_desc,
- disk_partition_t *fs_partition)
+ struct disk_partition *fs_partition)
{
- printf("** Unrecognized filesystem type **\n");
+ log_err("** Unrecognized filesystem type **\n");
return -1;
}
if (dent->type == FS_DT_DIR) {
printf(" %s/\n", dent->name);
ndirs++;
+ } else if (dent->type == FS_DT_LNK) {
+ printf(" <SYM> %s\n", dent->name);
+ nfiles++;
} else {
printf(" %8lld %s\n", dent->size, dent->name);
nfiles++;
return -1;
}
+static inline int fs_ln_unsupported(const char *filename, const char *target)
+{
+ return -1;
+}
+
static inline void fs_close_unsupported(void)
{
}
*/
bool null_dev_desc_ok;
int (*probe)(struct blk_desc *fs_dev_desc,
- disk_partition_t *fs_partition);
+ struct disk_partition *fs_partition);
int (*ls)(const char *dirname);
int (*exists)(const char *filename);
int (*size)(const char *filename, loff_t *size);
void (*closedir)(struct fs_dir_stream *dirs);
int (*unlink)(const char *filename);
int (*mkdir)(const char *dirname);
+ int (*ln)(const char *filename, const char *target);
};
static struct fstype_info fstypes[] = {
.exists = fat_exists,
.size = fat_size,
.read = fat_read_file,
-#ifdef CONFIG_FAT_WRITE
+#if CONFIG_IS_ENABLED(FAT_WRITE)
.write = file_fat_write,
.unlink = fat_unlink,
.mkdir = fat_mkdir,
.unlink = fs_unlink_unsupported,
.mkdir = fs_mkdir_unsupported,
#endif
- .uuid = fs_uuid_unsupported,
+ .uuid = fat_uuid,
.opendir = fat_opendir,
.readdir = fat_readdir,
.closedir = fat_closedir,
+ .ln = fs_ln_unsupported,
},
#endif
-#ifdef CONFIG_FS_EXT4
+
+#if CONFIG_IS_ENABLED(FS_EXT4)
{
.fstype = FS_TYPE_EXT,
.name = "ext4",
.read = ext4_read_file,
#ifdef CONFIG_CMD_EXT4_WRITE
.write = ext4_write_file,
+ .ln = ext4fs_create_link,
#else
.write = fs_write_unsupported,
+ .ln = fs_ln_unsupported,
#endif
.uuid = ext4fs_uuid,
.opendir = fs_opendir_unsupported,
.opendir = fs_opendir_unsupported,
.unlink = fs_unlink_unsupported,
.mkdir = fs_mkdir_unsupported,
+ .ln = fs_ln_unsupported,
},
#endif
#ifdef CONFIG_CMD_UBIFS
.opendir = fs_opendir_unsupported,
.unlink = fs_unlink_unsupported,
.mkdir = fs_mkdir_unsupported,
+ .ln = fs_ln_unsupported,
},
#endif
#ifdef CONFIG_FS_BTRFS
.opendir = fs_opendir_unsupported,
.unlink = fs_unlink_unsupported,
.mkdir = fs_mkdir_unsupported,
+ .ln = fs_ln_unsupported,
+ },
+#endif
+#if IS_ENABLED(CONFIG_FS_SQUASHFS)
+ {
+ .fstype = FS_TYPE_SQUASHFS,
+ .name = "squashfs",
+ .null_dev_desc_ok = false,
+ .probe = sqfs_probe,
+ .opendir = sqfs_opendir,
+ .readdir = sqfs_readdir,
+ .ls = fs_ls_generic,
+ .read = sqfs_read,
+ .size = sqfs_size,
+ .close = sqfs_close,
+ .closedir = sqfs_closedir,
+ .exists = sqfs_exists,
+ .uuid = fs_uuid_unsupported,
+ .write = fs_write_unsupported,
+ .ln = fs_ln_unsupported,
+ .unlink = fs_unlink_unsupported,
+ .mkdir = fs_mkdir_unsupported,
},
#endif
{
.opendir = fs_opendir_unsupported,
.unlink = fs_unlink_unsupported,
.mkdir = fs_mkdir_unsupported,
+ .ln = fs_ln_unsupported,
},
};
return info;
}
+/**
+ * fs_get_type() - Get type of current filesystem
+ *
+ * Return: filesystem type
+ *
+ * Returns filesystem type representing the current filesystem, or
+ * FS_TYPE_ANY for any unrecognised filesystem.
+ */
+int fs_get_type(void)
+{
+ return fs_type;
+}
+
/**
* fs_get_type_name() - Get type of current filesystem
*
}
#endif
- part = blk_get_device_part_str(ifname, dev_part_str, &fs_dev_desc,
- &fs_partition, 1);
+ part = part_get_info_by_dev_and_name_or_num(ifname, dev_part_str, &fs_dev_desc,
+ &fs_partition, 1);
if (part < 0)
return -1;
return -1;
}
-static void fs_close(void)
+void fs_close(void)
{
struct fstype_info *info = fs_get_info(fs_type);
ret = info->ls(dirname);
- fs_type = FS_TYPE_ANY;
fs_close();
return ret;
return ret;
}
-int fs_read(const char *filename, ulong addr, loff_t offset, loff_t len,
- loff_t *actread)
+#ifdef CONFIG_LMB
+/* Check if a file may be read to the given address */
+static int fs_read_lmb_check(const char *filename, ulong addr, loff_t offset,
+ loff_t len, struct fstype_info *info)
+{
+ struct lmb lmb;
+ int ret;
+ loff_t size;
+ loff_t read_len;
+
+ /* get the actual size of the file */
+ ret = info->size(filename, &size);
+ if (ret)
+ return ret;
+ if (offset >= size) {
+ /* offset >= EOF, no bytes will be written */
+ return 0;
+ }
+ read_len = size - offset;
+
+ /* limit to 'len' if it is smaller */
+ if (len && len < read_len)
+ read_len = len;
+
+ lmb_init_and_reserve(&lmb, gd->bd, (void *)gd->fdt_blob);
+ lmb_dump_all(&lmb);
+
+ if (lmb_alloc_addr(&lmb, addr, read_len) == addr)
+ return 0;
+
+ log_err("** Reading file would overwrite reserved memory **\n");
+ return -ENOSPC;
+}
+#endif
+
+static int _fs_read(const char *filename, ulong addr, loff_t offset, loff_t len,
+ int do_lmb_check, loff_t *actread)
{
struct fstype_info *info = fs_get_info(fs_type);
void *buf;
int ret;
+#ifdef CONFIG_LMB
+ if (do_lmb_check) {
+ ret = fs_read_lmb_check(filename, addr, offset, len, info);
+ if (ret)
+ return ret;
+ }
+#endif
+
/*
* We don't actually know how many bytes are being read, since len==0
* means read the whole file.
/* If we requested a specific number of bytes, check we got it */
if (ret == 0 && len && *actread != len)
- debug("** %s shorter than offset + len **\n", filename);
+ log_debug("** %s shorter than offset + len **\n", filename);
fs_close();
return ret;
}
+int fs_read(const char *filename, ulong addr, loff_t offset, loff_t len,
+ loff_t *actread)
+{
+ return _fs_read(filename, addr, offset, len, 0, actread);
+}
+
int fs_write(const char *filename, ulong addr, loff_t offset, loff_t len,
loff_t *actwrite)
{
unmap_sysmem(buf);
if (ret < 0 && len != *actwrite) {
- printf("** Unable to write file %s **\n", filename);
+ log_err("** Unable to write file %s **\n", filename);
ret = -1;
}
fs_close();
ret = info->unlink(filename);
- fs_type = FS_TYPE_ANY;
fs_close();
return ret;
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)
+int fs_ln(const char *fname, const char *target)
+{
+ struct fstype_info *info = fs_get_info(fs_type);
+ int ret;
+
+ ret = info->ln(fname, target);
+
+ if (ret < 0) {
+ log_err("** Unable to create link %s -> %s **\n", fname, target);
+ ret = -1;
+ }
+ fs_close();
+
+ return ret;
+}
+
+int do_size(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
+ int fstype)
{
loff_t size;
return 0;
}
-int do_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
- int fstype)
+int do_load(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
+ int fstype)
{
unsigned long addr;
const char *addr_str;
if (argc > 7)
return CMD_RET_USAGE;
- if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
+ if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype)) {
+ log_err("Can't set block device\n");
return 1;
+ }
if (argc >= 4) {
addr = simple_strtoul(argv[3], &ep, 16);
pos = 0;
time = get_timer(0);
- ret = fs_read(filename, addr, pos, bytes, &len_read);
+ ret = _fs_read(filename, addr, pos, bytes, 1, &len_read);
time = get_timer(time);
- if (ret < 0)
+ if (ret < 0) {
+ log_err("Failed to load '%s'\n", filename);
return 1;
+ }
+
+ if (IS_ENABLED(CONFIG_CMD_BOOTEFI))
+ efi_set_bootdev(argv[1], (argc > 2) ? argv[2] : "",
+ (argc > 4) ? argv[4] : "", map_sysmem(addr, 0),
+ len_read);
printf("%llu bytes read in %lu ms", len_read, time);
if (time > 0) {
return 0;
}
-int do_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
- int fstype)
+int do_ls(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
+ int fstype)
{
if (argc < 2)
return CMD_RET_USAGE;
return fs_exists(file);
}
-int do_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
- int fstype)
+int do_save(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
+ int fstype)
{
unsigned long addr;
const char *filename;
return 0;
}
-int do_fs_uuid(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
- int fstype)
+int do_fs_uuid(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
+ int fstype)
{
int ret;
char uuid[37];
return CMD_RET_SUCCESS;
}
-int do_fs_type(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_fs_type(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct fstype_info *info;
else
printf("%s\n", info->name);
+ fs_close();
+
return CMD_RET_SUCCESS;
}
-int do_rm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
+int do_rm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
int fstype)
{
if (argc != 4)
return 0;
}
-int do_mkdir(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
+int do_mkdir(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
int fstype)
{
int ret;
ret = fs_mkdir(argv[3]);
if (ret) {
- printf("** Unable to create a directory \"%s\" **\n", argv[3]);
+ log_err("** Unable to create a directory \"%s\" **\n", argv[3]);
return 1;
}
return 0;
}
+
+int do_ln(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
+ int fstype)
+{
+ if (argc != 5)
+ return CMD_RET_USAGE;
+
+ if (fs_set_blk_dev(argv[1], argv[2], fstype))
+ return 1;
+
+ if (fs_ln(argv[3], argv[4]))
+ return 1;
+
+ return 0;
+}
+
+int do_fs_types(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[])
+{
+ struct fstype_info *drv = fstypes;
+ const int n_ents = ARRAY_SIZE(fstypes);
+ struct fstype_info *entry;
+ int i = 0;
+
+ puts("Supported filesystems");
+ for (entry = drv; entry != drv + n_ents; entry++) {
+ if (entry->fstype != FS_TYPE_ANY) {
+ printf("%c %s", i ? ',' : ':', entry->name);
+ i++;
+ }
+ }
+ if (!i)
+ puts(": <none>");
+ puts("\n");
+ return CMD_RET_SUCCESS;
+}
projects / u-boot.git / blobdiff