blob: cfc781bbb8d810dd50ae518abe0278b4b21c804a [file] [log] [blame]
Tom Rini10e47792018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0
Stephen Warreneefbc3f2012-10-22 06:43:51 +00002/*
3 * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved.
Stephen Warreneefbc3f2012-10-22 06:43:51 +00004 */
5
Heinrich Schuchardtb4559782020-08-25 17:49:16 +00006#define LOG_CATEGORY LOGC_CORE
7
Simon Glassed38aef2020-05-10 11:40:03 -06008#include <command.h>
Stephen Warreneefbc3f2012-10-22 06:43:51 +00009#include <config.h>
Simon Glass1ab16922022-07-31 12:28:48 -060010#include <display_options.h>
Christian Gmeiner9f9eec32014-11-12 14:35:04 +010011#include <errno.h>
Stephen Warreneefbc3f2012-10-22 06:43:51 +000012#include <common.h>
Simon Glass313112a2019-08-01 09:46:46 -060013#include <env.h>
Simon Glass655306c2020-05-10 11:39:58 -060014#include <lmb.h>
Simon Glass0f2af882020-05-10 11:40:05 -060015#include <log.h>
Simon Glasse6c49fc2023-06-01 10:22:38 -060016#include <malloc.h>
Joe Hershberger65b905b2015-03-22 17:08:59 -050017#include <mapmem.h>
Stephen Warreneefbc3f2012-10-22 06:43:51 +000018#include <part.h>
19#include <ext4fs.h>
20#include <fat.h>
21#include <fs.h>
Simon Glass11842872012-12-26 09:53:35 +000022#include <sandboxfs.h>
Sean Andersonc678b322022-03-22 16:59:20 -040023#include <semihostingfs.h>
Hans de Goede690c7962015-09-17 18:46:58 -040024#include <ubifs_uboot.h>
Marek BehĂșn98ec1d12017-09-03 17:00:29 +020025#include <btrfs.h>
Simon Glass3ba929a2020-10-30 21:38:53 -060026#include <asm/global_data.h>
Simon Glasscbe5d5d2012-12-26 09:53:32 +000027#include <asm/io.h>
Tom Rinia17b7bc2014-11-24 11:50:46 -050028#include <div64.h>
29#include <linux/math64.h>
Simon Glasse6c49fc2023-06-01 10:22:38 -060030#include <linux/sizes.h>
Mian Yousaf Kaukab961ebe82019-06-18 15:03:44 +020031#include <efi_loader.h>
Joao Marcos Costa29da3742020-07-30 15:33:47 +020032#include <squashfs.h>
Huang Jianan024fb2f2022-02-26 15:05:47 +080033#include <erofs.h>
Stephen Warreneefbc3f2012-10-22 06:43:51 +000034
Stephen Warren44161af2012-10-30 07:50:47 +000035DECLARE_GLOBAL_DATA_PTR;
36
Simon Glasse3394752016-02-29 15:25:34 -070037static struct blk_desc *fs_dev_desc;
Rob Clark2b7bfd92017-09-09 13:15:55 -040038static int fs_dev_part;
Simon Glassc1c4a8f2020-05-10 11:39:57 -060039static struct disk_partition fs_partition;
Stephen Warreneefbc3f2012-10-22 06:43:51 +000040static int fs_type = FS_TYPE_ANY;
41
Simon Glass896ed4b2022-04-24 23:31:04 -060042void fs_set_type(int type)
43{
44 fs_type = type;
45}
46
Simon Glasse3394752016-02-29 15:25:34 -070047static inline int fs_probe_unsupported(struct blk_desc *fs_dev_desc,
Simon Glassc1c4a8f2020-05-10 11:39:57 -060048 struct disk_partition *fs_partition)
Simon Glass1aede482012-12-26 09:53:29 +000049{
Heinrich Schuchardt3f006d52021-09-20 14:15:03 +020050 log_debug("Unrecognized filesystem type\n");
Simon Glass1aede482012-12-26 09:53:29 +000051 return -1;
52}
53
Stephen Warreneefbc3f2012-10-22 06:43:51 +000054static inline int fs_ls_unsupported(const char *dirname)
55{
Stephen Warreneefbc3f2012-10-22 06:43:51 +000056 return -1;
57}
58
Rob Clark60d74a92017-09-09 13:15:58 -040059/* generic implementation of ls in terms of opendir/readdir/closedir */
60__maybe_unused
61static int fs_ls_generic(const char *dirname)
62{
63 struct fs_dir_stream *dirs;
64 struct fs_dirent *dent;
65 int nfiles = 0, ndirs = 0;
66
67 dirs = fs_opendir(dirname);
68 if (!dirs)
69 return -errno;
70
71 while ((dent = fs_readdir(dirs))) {
72 if (dent->type == FS_DT_DIR) {
73 printf(" %s/\n", dent->name);
74 ndirs++;
Joao Marcos Costa2a7fb152020-07-30 15:33:51 +020075 } else if (dent->type == FS_DT_LNK) {
76 printf(" <SYM> %s\n", dent->name);
77 nfiles++;
Rob Clark60d74a92017-09-09 13:15:58 -040078 } else {
79 printf(" %8lld %s\n", dent->size, dent->name);
80 nfiles++;
81 }
82 }
83
84 fs_closedir(dirs);
85
86 printf("\n%d file(s), %d dir(s)\n\n", nfiles, ndirs);
87
88 return 0;
89}
90
Stephen Warrend008fbb2014-02-03 13:21:00 -070091static inline int fs_exists_unsupported(const char *filename)
92{
93 return 0;
94}
95
Suriyan Ramasami96171fb2014-11-17 14:39:38 -080096static inline int fs_size_unsupported(const char *filename, loff_t *size)
Stephen Warren3eb58f52014-06-11 12:47:26 -060097{
98 return -1;
99}
100
Simon Glasscbe5d5d2012-12-26 09:53:32 +0000101static inline int fs_read_unsupported(const char *filename, void *buf,
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800102 loff_t offset, loff_t len,
103 loff_t *actread)
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000104{
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000105 return -1;
106}
107
Simon Glasseda14ea2013-04-20 08:42:50 +0000108static inline int fs_write_unsupported(const char *filename, void *buf,
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800109 loff_t offset, loff_t len,
110 loff_t *actwrite)
Simon Glasseda14ea2013-04-20 08:42:50 +0000111{
112 return -1;
113}
114
Jean-Jacques Hiblotbc237482019-02-13 12:15:26 +0100115static inline int fs_ln_unsupported(const char *filename, const char *target)
116{
117 return -1;
118}
119
Simon Glass1aede482012-12-26 09:53:29 +0000120static inline void fs_close_unsupported(void)
121{
122}
123
Christian Gmeiner9f9eec32014-11-12 14:35:04 +0100124static inline int fs_uuid_unsupported(char *uuid_str)
125{
126 return -1;
127}
128
Rob Clark2b7bfd92017-09-09 13:15:55 -0400129static inline int fs_opendir_unsupported(const char *filename,
130 struct fs_dir_stream **dirs)
131{
132 return -EACCES;
133}
134
AKASHI Takahiro1ba42532018-09-11 15:59:13 +0900135static inline int fs_unlink_unsupported(const char *filename)
136{
137 return -1;
138}
139
AKASHI Takahiroadc8c9f2018-09-11 15:59:08 +0900140static inline int fs_mkdir_unsupported(const char *dirname)
141{
142 return -1;
143}
144
Simon Glass1aede482012-12-26 09:53:29 +0000145struct fstype_info {
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000146 int fstype;
Sjoerd Simons7d9faf62015-01-05 18:13:36 +0100147 char *name;
Stephen Warrenec63d4a2014-02-03 13:21:01 -0700148 /*
149 * Is it legal to pass NULL as .probe()'s fs_dev_desc parameter? This
150 * should be false in most cases. For "virtual" filesystems which
151 * aren't based on a U-Boot block device (e.g. sandbox), this can be
Heinrich Schuchardt99dc17d2018-08-11 15:52:14 +0200152 * set to true. This should also be true for the dummy entry at the end
Stephen Warrenec63d4a2014-02-03 13:21:01 -0700153 * of fstypes[], since that is essentially a "virtual" (non-existent)
154 * filesystem.
155 */
156 bool null_dev_desc_ok;
Simon Glasse3394752016-02-29 15:25:34 -0700157 int (*probe)(struct blk_desc *fs_dev_desc,
Simon Glassc1c4a8f2020-05-10 11:39:57 -0600158 struct disk_partition *fs_partition);
Simon Glass1aede482012-12-26 09:53:29 +0000159 int (*ls)(const char *dirname);
Stephen Warrend008fbb2014-02-03 13:21:00 -0700160 int (*exists)(const char *filename);
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800161 int (*size)(const char *filename, loff_t *size);
162 int (*read)(const char *filename, void *buf, loff_t offset,
163 loff_t len, loff_t *actread);
164 int (*write)(const char *filename, void *buf, loff_t offset,
165 loff_t len, loff_t *actwrite);
Simon Glass1aede482012-12-26 09:53:29 +0000166 void (*close)(void);
Christian Gmeiner9f9eec32014-11-12 14:35:04 +0100167 int (*uuid)(char *uuid_str);
Rob Clark2b7bfd92017-09-09 13:15:55 -0400168 /*
169 * Open a directory stream. On success return 0 and directory
170 * stream pointer via 'dirsp'. On error, return -errno. See
171 * fs_opendir().
172 */
173 int (*opendir)(const char *filename, struct fs_dir_stream **dirsp);
174 /*
175 * Read next entry from directory stream. On success return 0
176 * and directory entry pointer via 'dentp'. On error return
177 * -errno. See fs_readdir().
178 */
179 int (*readdir)(struct fs_dir_stream *dirs, struct fs_dirent **dentp);
180 /* see fs_closedir() */
181 void (*closedir)(struct fs_dir_stream *dirs);
AKASHI Takahiro1ba42532018-09-11 15:59:13 +0900182 int (*unlink)(const char *filename);
AKASHI Takahiroadc8c9f2018-09-11 15:59:08 +0900183 int (*mkdir)(const char *dirname);
Jean-Jacques Hiblotbc237482019-02-13 12:15:26 +0100184 int (*ln)(const char *filename, const char *target);
Simon Glass1aede482012-12-26 09:53:29 +0000185};
186
187static struct fstype_info fstypes[] = {
Pali RohĂĄrd291f892022-04-05 15:48:32 +0200188#if CONFIG_IS_ENABLED(FS_FAT)
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000189 {
190 .fstype = FS_TYPE_FAT,
Sjoerd Simons7d9faf62015-01-05 18:13:36 +0100191 .name = "fat",
Stephen Warrenec63d4a2014-02-03 13:21:01 -0700192 .null_dev_desc_ok = false,
Simon Glass19e38582012-12-26 09:53:33 +0000193 .probe = fat_set_blk_dev,
194 .close = fat_close,
Rob Clark60d74a92017-09-09 13:15:58 -0400195 .ls = fs_ls_generic,
Stephen Warren1d2f9a02014-02-03 13:21:10 -0700196 .exists = fat_exists,
Stephen Warren3eb58f52014-06-11 12:47:26 -0600197 .size = fat_size,
Simon Glass19e38582012-12-26 09:53:33 +0000198 .read = fat_read_file,
Tien Fong Chee87fda0c2019-01-23 14:20:04 +0800199#if CONFIG_IS_ENABLED(FAT_WRITE)
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800200 .write = file_fat_write,
AKASHI Takahiro73b34972018-09-11 15:59:14 +0900201 .unlink = fat_unlink,
AKASHI Takahiro1c24b7b2018-09-11 15:59:10 +0900202 .mkdir = fat_mkdir,
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800203#else
Stephen Warren9df25802014-02-03 13:20:59 -0700204 .write = fs_write_unsupported,
AKASHI Takahiro73b34972018-09-11 15:59:14 +0900205 .unlink = fs_unlink_unsupported,
AKASHI Takahiro1c24b7b2018-09-11 15:59:10 +0900206 .mkdir = fs_mkdir_unsupported,
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800207#endif
Heinrich Schuchardtfac91832020-12-31 00:38:13 +0100208 .uuid = fat_uuid,
Rob Clark60d74a92017-09-09 13:15:58 -0400209 .opendir = fat_opendir,
210 .readdir = fat_readdir,
211 .closedir = fat_closedir,
Jean-Jacques Hiblotbc237482019-02-13 12:15:26 +0100212 .ln = fs_ln_unsupported,
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000213 },
Simon Glass1aede482012-12-26 09:53:29 +0000214#endif
Tien Fong Chee64eab042019-01-23 14:20:06 +0800215
216#if CONFIG_IS_ENABLED(FS_EXT4)
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000217 {
218 .fstype = FS_TYPE_EXT,
Sjoerd Simons7d9faf62015-01-05 18:13:36 +0100219 .name = "ext4",
Stephen Warrenec63d4a2014-02-03 13:21:01 -0700220 .null_dev_desc_ok = false,
Simon Glass19e38582012-12-26 09:53:33 +0000221 .probe = ext4fs_probe,
222 .close = ext4fs_close,
Simon Glass1aede482012-12-26 09:53:29 +0000223 .ls = ext4fs_ls,
Stephen Warren12d6d0c2014-02-03 13:21:09 -0700224 .exists = ext4fs_exists,
Stephen Warren3eb58f52014-06-11 12:47:26 -0600225 .size = ext4fs_size,
Simon Glass19e38582012-12-26 09:53:33 +0000226 .read = ext4_read_file,
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800227#ifdef CONFIG_CMD_EXT4_WRITE
228 .write = ext4_write_file,
Jean-Jacques Hiblotbc237482019-02-13 12:15:26 +0100229 .ln = ext4fs_create_link,
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800230#else
Stephen Warren9df25802014-02-03 13:20:59 -0700231 .write = fs_write_unsupported,
Jean-Jacques Hiblotbc237482019-02-13 12:15:26 +0100232 .ln = fs_ln_unsupported,
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800233#endif
Christian Gmeiner9f9eec32014-11-12 14:35:04 +0100234 .uuid = ext4fs_uuid,
Rob Clark2b7bfd92017-09-09 13:15:55 -0400235 .opendir = fs_opendir_unsupported,
AKASHI Takahiro1ba42532018-09-11 15:59:13 +0900236 .unlink = fs_unlink_unsupported,
AKASHI Takahiroadc8c9f2018-09-11 15:59:08 +0900237 .mkdir = fs_mkdir_unsupported,
Simon Glass1aede482012-12-26 09:53:29 +0000238 },
239#endif
Simon Glass11842872012-12-26 09:53:35 +0000240#ifdef CONFIG_SANDBOX
241 {
242 .fstype = FS_TYPE_SANDBOX,
Sjoerd Simons7d9faf62015-01-05 18:13:36 +0100243 .name = "sandbox",
Stephen Warrenec63d4a2014-02-03 13:21:01 -0700244 .null_dev_desc_ok = true,
Simon Glass11842872012-12-26 09:53:35 +0000245 .probe = sandbox_fs_set_blk_dev,
246 .close = sandbox_fs_close,
247 .ls = sandbox_fs_ls,
Stephen Warren97d66f22014-02-03 13:21:07 -0700248 .exists = sandbox_fs_exists,
Stephen Warren3eb58f52014-06-11 12:47:26 -0600249 .size = sandbox_fs_size,
Simon Glass11842872012-12-26 09:53:35 +0000250 .read = fs_read_sandbox,
Simon Glassea307e82013-04-20 08:42:51 +0000251 .write = fs_write_sandbox,
Christian Gmeiner9f9eec32014-11-12 14:35:04 +0100252 .uuid = fs_uuid_unsupported,
Rob Clark2b7bfd92017-09-09 13:15:55 -0400253 .opendir = fs_opendir_unsupported,
AKASHI Takahiro1ba42532018-09-11 15:59:13 +0900254 .unlink = fs_unlink_unsupported,
AKASHI Takahiroadc8c9f2018-09-11 15:59:08 +0900255 .mkdir = fs_mkdir_unsupported,
Jean-Jacques Hiblotbc237482019-02-13 12:15:26 +0100256 .ln = fs_ln_unsupported,
Simon Glass11842872012-12-26 09:53:35 +0000257 },
258#endif
Sean Andersonc678b322022-03-22 16:59:20 -0400259#ifdef CONFIG_SEMIHOSTING
260 {
261 .fstype = FS_TYPE_SEMIHOSTING,
262 .name = "semihosting",
263 .null_dev_desc_ok = true,
264 .probe = smh_fs_set_blk_dev,
265 .close = fs_close_unsupported,
266 .ls = fs_ls_unsupported,
267 .exists = fs_exists_unsupported,
268 .size = smh_fs_size,
269 .read = smh_fs_read,
270 .write = smh_fs_write,
271 .uuid = fs_uuid_unsupported,
272 .opendir = fs_opendir_unsupported,
273 .unlink = fs_unlink_unsupported,
274 .mkdir = fs_mkdir_unsupported,
275 .ln = fs_ln_unsupported,
276 },
277#endif
Pali RohĂĄrd3a3c122022-04-05 15:49:24 +0200278#ifndef CONFIG_SPL_BUILD
Hans de Goede690c7962015-09-17 18:46:58 -0400279#ifdef CONFIG_CMD_UBIFS
280 {
281 .fstype = FS_TYPE_UBIFS,
282 .name = "ubifs",
283 .null_dev_desc_ok = true,
284 .probe = ubifs_set_blk_dev,
285 .close = ubifs_close,
286 .ls = ubifs_ls,
287 .exists = ubifs_exists,
288 .size = ubifs_size,
289 .read = ubifs_read,
290 .write = fs_write_unsupported,
291 .uuid = fs_uuid_unsupported,
Rob Clark2b7bfd92017-09-09 13:15:55 -0400292 .opendir = fs_opendir_unsupported,
AKASHI Takahiro1ba42532018-09-11 15:59:13 +0900293 .unlink = fs_unlink_unsupported,
AKASHI Takahiroadc8c9f2018-09-11 15:59:08 +0900294 .mkdir = fs_mkdir_unsupported,
Jean-Jacques Hiblotbc237482019-02-13 12:15:26 +0100295 .ln = fs_ln_unsupported,
Hans de Goede690c7962015-09-17 18:46:58 -0400296 },
297#endif
Pali RohĂĄrd3a3c122022-04-05 15:49:24 +0200298#endif
Pali RohĂĄr849a61a2022-04-07 14:53:25 +0200299#ifndef CONFIG_SPL_BUILD
Marek BehĂșn98ec1d12017-09-03 17:00:29 +0200300#ifdef CONFIG_FS_BTRFS
301 {
302 .fstype = FS_TYPE_BTRFS,
303 .name = "btrfs",
304 .null_dev_desc_ok = false,
305 .probe = btrfs_probe,
306 .close = btrfs_close,
307 .ls = btrfs_ls,
308 .exists = btrfs_exists,
309 .size = btrfs_size,
310 .read = btrfs_read,
311 .write = fs_write_unsupported,
312 .uuid = btrfs_uuid,
Marek BehĂșn90762d92017-10-06 16:56:07 +0200313 .opendir = fs_opendir_unsupported,
AKASHI Takahiro1ba42532018-09-11 15:59:13 +0900314 .unlink = fs_unlink_unsupported,
AKASHI Takahiroadc8c9f2018-09-11 15:59:08 +0900315 .mkdir = fs_mkdir_unsupported,
Jean-Jacques Hiblotbc237482019-02-13 12:15:26 +0100316 .ln = fs_ln_unsupported,
Marek BehĂșn98ec1d12017-09-03 17:00:29 +0200317 },
318#endif
Pali RohĂĄr849a61a2022-04-07 14:53:25 +0200319#endif
Pali RohĂĄr1660e962022-04-06 23:34:00 +0200320#if CONFIG_IS_ENABLED(FS_SQUASHFS)
Joao Marcos Costa29da3742020-07-30 15:33:47 +0200321 {
322 .fstype = FS_TYPE_SQUASHFS,
323 .name = "squashfs",
Richard Genoud654b2482020-11-03 12:10:59 +0100324 .null_dev_desc_ok = false,
Joao Marcos Costa29da3742020-07-30 15:33:47 +0200325 .probe = sqfs_probe,
326 .opendir = sqfs_opendir,
327 .readdir = sqfs_readdir,
328 .ls = fs_ls_generic,
329 .read = sqfs_read,
330 .size = sqfs_size,
331 .close = sqfs_close,
332 .closedir = sqfs_closedir,
Richard Genoudcfca20c2020-11-03 12:11:26 +0100333 .exists = sqfs_exists,
Richard Genoud654b2482020-11-03 12:10:59 +0100334 .uuid = fs_uuid_unsupported,
335 .write = fs_write_unsupported,
336 .ln = fs_ln_unsupported,
337 .unlink = fs_unlink_unsupported,
338 .mkdir = fs_mkdir_unsupported,
Joao Marcos Costa29da3742020-07-30 15:33:47 +0200339 },
340#endif
Huang Jianan024fb2f2022-02-26 15:05:47 +0800341#if IS_ENABLED(CONFIG_FS_EROFS)
342 {
343 .fstype = FS_TYPE_EROFS,
344 .name = "erofs",
345 .null_dev_desc_ok = false,
346 .probe = erofs_probe,
347 .opendir = erofs_opendir,
348 .readdir = erofs_readdir,
349 .ls = fs_ls_generic,
350 .read = erofs_read,
351 .size = erofs_size,
352 .close = erofs_close,
353 .closedir = erofs_closedir,
354 .exists = erofs_exists,
355 .uuid = fs_uuid_unsupported,
356 .write = fs_write_unsupported,
357 .ln = fs_ln_unsupported,
358 .unlink = fs_unlink_unsupported,
359 .mkdir = fs_mkdir_unsupported,
360 },
361#endif
Simon Glass1aede482012-12-26 09:53:29 +0000362 {
363 .fstype = FS_TYPE_ANY,
Sjoerd Simons7d9faf62015-01-05 18:13:36 +0100364 .name = "unsupported",
Stephen Warrenec63d4a2014-02-03 13:21:01 -0700365 .null_dev_desc_ok = true,
Simon Glass1aede482012-12-26 09:53:29 +0000366 .probe = fs_probe_unsupported,
367 .close = fs_close_unsupported,
368 .ls = fs_ls_unsupported,
Stephen Warrend008fbb2014-02-03 13:21:00 -0700369 .exists = fs_exists_unsupported,
Stephen Warren3eb58f52014-06-11 12:47:26 -0600370 .size = fs_size_unsupported,
Simon Glass1aede482012-12-26 09:53:29 +0000371 .read = fs_read_unsupported,
Simon Glasseda14ea2013-04-20 08:42:50 +0000372 .write = fs_write_unsupported,
Christian Gmeiner9f9eec32014-11-12 14:35:04 +0100373 .uuid = fs_uuid_unsupported,
Rob Clark2b7bfd92017-09-09 13:15:55 -0400374 .opendir = fs_opendir_unsupported,
AKASHI Takahiro1ba42532018-09-11 15:59:13 +0900375 .unlink = fs_unlink_unsupported,
AKASHI Takahiroadc8c9f2018-09-11 15:59:08 +0900376 .mkdir = fs_mkdir_unsupported,
Jean-Jacques Hiblotbc237482019-02-13 12:15:26 +0100377 .ln = fs_ln_unsupported,
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000378 },
379};
380
Simon Glasse6aad852012-12-26 09:53:30 +0000381static struct fstype_info *fs_get_info(int fstype)
382{
383 struct fstype_info *info;
384 int i;
385
386 for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes) - 1; i++, info++) {
387 if (fstype == info->fstype)
388 return info;
389 }
390
391 /* Return the 'unsupported' sentinel */
392 return info;
393}
394
Alex Kiernan3a6163a2018-05-29 15:30:50 +0000395/**
AKASHI Takahiro80ac7342019-10-07 14:59:37 +0900396 * fs_get_type() - Get type of current filesystem
397 *
398 * Return: filesystem type
399 *
400 * Returns filesystem type representing the current filesystem, or
401 * FS_TYPE_ANY for any unrecognised filesystem.
402 */
403int fs_get_type(void)
404{
405 return fs_type;
406}
407
408/**
Alex Kiernan3a6163a2018-05-29 15:30:50 +0000409 * fs_get_type_name() - Get type of current filesystem
410 *
411 * Return: Pointer to filesystem name
412 *
413 * Returns a string describing the current filesystem, or the sentinel
414 * "unsupported" for any unrecognised filesystem.
415 */
416const char *fs_get_type_name(void)
417{
418 return fs_get_info(fs_type)->name;
419}
420
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000421int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype)
422{
Simon Glass1aede482012-12-26 09:53:29 +0000423 struct fstype_info *info;
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000424 int part, i;
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000425
Sean Andersonf476b4a2021-04-12 18:53:05 -0400426 part = part_get_info_by_dev_and_name_or_num(ifname, dev_part_str, &fs_dev_desc,
427 &fs_partition, 1);
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000428 if (part < 0)
429 return -1;
430
Simon Glass1aede482012-12-26 09:53:29 +0000431 for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes); i++, info++) {
432 if (fstype != FS_TYPE_ANY && info->fstype != FS_TYPE_ANY &&
433 fstype != info->fstype)
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000434 continue;
435
Stephen Warrenec63d4a2014-02-03 13:21:01 -0700436 if (!fs_dev_desc && !info->null_dev_desc_ok)
437 continue;
438
Simon Glass6a46e2f2012-12-26 09:53:31 +0000439 if (!info->probe(fs_dev_desc, &fs_partition)) {
Simon Glass1aede482012-12-26 09:53:29 +0000440 fs_type = info->fstype;
Rob Clark2b7bfd92017-09-09 13:15:55 -0400441 fs_dev_part = part;
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000442 return 0;
443 }
444 }
445
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000446 return -1;
447}
448
Rob Clark2b7bfd92017-09-09 13:15:55 -0400449/* set current blk device w/ blk_desc + partition # */
450int fs_set_blk_dev_with_part(struct blk_desc *desc, int part)
451{
452 struct fstype_info *info;
453 int ret, i;
454
455 if (part >= 1)
456 ret = part_get_info(desc, part, &fs_partition);
457 else
458 ret = part_get_info_whole_disk(desc, &fs_partition);
459 if (ret)
460 return ret;
461 fs_dev_desc = desc;
462
463 for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes); i++, info++) {
464 if (!info->probe(fs_dev_desc, &fs_partition)) {
465 fs_type = info->fstype;
AKASHI Takahiro43efaa02018-10-17 16:32:02 +0900466 fs_dev_part = part;
Rob Clark2b7bfd92017-09-09 13:15:55 -0400467 return 0;
468 }
469 }
470
471 return -1;
472}
473
AKASHI Takahiroca8e3772019-10-07 14:59:35 +0900474void fs_close(void)
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000475{
Simon Glasse6aad852012-12-26 09:53:30 +0000476 struct fstype_info *info = fs_get_info(fs_type);
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000477
Simon Glasse6aad852012-12-26 09:53:30 +0000478 info->close();
Simon Glass19e38582012-12-26 09:53:33 +0000479
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000480 fs_type = FS_TYPE_ANY;
481}
482
Christian Gmeiner9f9eec32014-11-12 14:35:04 +0100483int fs_uuid(char *uuid_str)
484{
485 struct fstype_info *info = fs_get_info(fs_type);
486
487 return info->uuid(uuid_str);
488}
489
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000490int fs_ls(const char *dirname)
491{
492 int ret;
493
Simon Glasse6aad852012-12-26 09:53:30 +0000494 struct fstype_info *info = fs_get_info(fs_type);
495
496 ret = info->ls(dirname);
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000497
498 fs_close();
499
500 return ret;
501}
502
Stephen Warrend008fbb2014-02-03 13:21:00 -0700503int fs_exists(const char *filename)
504{
505 int ret;
506
507 struct fstype_info *info = fs_get_info(fs_type);
508
509 ret = info->exists(filename);
510
511 fs_close();
512
513 return ret;
514}
515
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800516int fs_size(const char *filename, loff_t *size)
Stephen Warren3eb58f52014-06-11 12:47:26 -0600517{
518 int ret;
519
520 struct fstype_info *info = fs_get_info(fs_type);
521
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800522 ret = info->size(filename, size);
Stephen Warren3eb58f52014-06-11 12:47:26 -0600523
524 fs_close();
525
526 return ret;
527}
528
Simon Goldschmidt5b2c6872019-01-14 22:38:19 +0100529#ifdef CONFIG_LMB
530/* Check if a file may be read to the given address */
531static int fs_read_lmb_check(const char *filename, ulong addr, loff_t offset,
532 loff_t len, struct fstype_info *info)
533{
534 struct lmb lmb;
535 int ret;
536 loff_t size;
537 loff_t read_len;
538
539 /* get the actual size of the file */
540 ret = info->size(filename, &size);
541 if (ret)
542 return ret;
543 if (offset >= size) {
544 /* offset >= EOF, no bytes will be written */
545 return 0;
546 }
547 read_len = size - offset;
548
549 /* limit to 'len' if it is smaller */
550 if (len && len < read_len)
551 read_len = len;
552
Simon Goldschmidt8890e7d2019-01-26 22:13:04 +0100553 lmb_init_and_reserve(&lmb, gd->bd, (void *)gd->fdt_blob);
Simon Goldschmidt5b2c6872019-01-14 22:38:19 +0100554 lmb_dump_all(&lmb);
555
556 if (lmb_alloc_addr(&lmb, addr, read_len) == addr)
557 return 0;
558
Heinrich Schuchardtb4559782020-08-25 17:49:16 +0000559 log_err("** Reading file would overwrite reserved memory **\n");
Simon Goldschmidt5b2c6872019-01-14 22:38:19 +0100560 return -ENOSPC;
561}
562#endif
563
564static int _fs_read(const char *filename, ulong addr, loff_t offset, loff_t len,
565 int do_lmb_check, loff_t *actread)
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000566{
Simon Glasse6aad852012-12-26 09:53:30 +0000567 struct fstype_info *info = fs_get_info(fs_type);
Simon Glasscbe5d5d2012-12-26 09:53:32 +0000568 void *buf;
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000569 int ret;
570
Simon Goldschmidt5b2c6872019-01-14 22:38:19 +0100571#ifdef CONFIG_LMB
572 if (do_lmb_check) {
573 ret = fs_read_lmb_check(filename, addr, offset, len, info);
574 if (ret)
575 return ret;
576 }
577#endif
578
Simon Glasscbe5d5d2012-12-26 09:53:32 +0000579 /*
580 * We don't actually know how many bytes are being read, since len==0
581 * means read the whole file.
582 */
583 buf = map_sysmem(addr, len);
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800584 ret = info->read(filename, buf, offset, len, actread);
Simon Glasscbe5d5d2012-12-26 09:53:32 +0000585 unmap_sysmem(buf);
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000586
Simon Glasse6aad852012-12-26 09:53:30 +0000587 /* If we requested a specific number of bytes, check we got it */
Max Krummenacher56d9cdf2015-08-05 17:16:58 +0200588 if (ret == 0 && len && *actread != len)
Heinrich Schuchardtb4559782020-08-25 17:49:16 +0000589 log_debug("** %s shorter than offset + len **\n", filename);
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000590 fs_close();
591
592 return ret;
593}
594
Simon Goldschmidt5b2c6872019-01-14 22:38:19 +0100595int fs_read(const char *filename, ulong addr, loff_t offset, loff_t len,
596 loff_t *actread)
597{
598 return _fs_read(filename, addr, offset, len, 0, actread);
599}
600
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800601int fs_write(const char *filename, ulong addr, loff_t offset, loff_t len,
602 loff_t *actwrite)
Simon Glasseda14ea2013-04-20 08:42:50 +0000603{
604 struct fstype_info *info = fs_get_info(fs_type);
605 void *buf;
606 int ret;
607
Simon Glasseda14ea2013-04-20 08:42:50 +0000608 buf = map_sysmem(addr, len);
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800609 ret = info->write(filename, buf, offset, len, actwrite);
Simon Glasseda14ea2013-04-20 08:42:50 +0000610 unmap_sysmem(buf);
611
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800612 if (ret < 0 && len != *actwrite) {
Heinrich Schuchardtb4559782020-08-25 17:49:16 +0000613 log_err("** Unable to write file %s **\n", filename);
Simon Glasseda14ea2013-04-20 08:42:50 +0000614 ret = -1;
615 }
616 fs_close();
617
618 return ret;
619}
620
Rob Clark2b7bfd92017-09-09 13:15:55 -0400621struct fs_dir_stream *fs_opendir(const char *filename)
622{
623 struct fstype_info *info = fs_get_info(fs_type);
624 struct fs_dir_stream *dirs = NULL;
625 int ret;
626
627 ret = info->opendir(filename, &dirs);
628 fs_close();
629 if (ret) {
630 errno = -ret;
631 return NULL;
632 }
633
634 dirs->desc = fs_dev_desc;
635 dirs->part = fs_dev_part;
636
637 return dirs;
638}
639
640struct fs_dirent *fs_readdir(struct fs_dir_stream *dirs)
641{
642 struct fstype_info *info;
643 struct fs_dirent *dirent;
644 int ret;
645
646 fs_set_blk_dev_with_part(dirs->desc, dirs->part);
647 info = fs_get_info(fs_type);
648
649 ret = info->readdir(dirs, &dirent);
650 fs_close();
651 if (ret) {
652 errno = -ret;
653 return NULL;
654 }
655
656 return dirent;
657}
658
659void fs_closedir(struct fs_dir_stream *dirs)
660{
661 struct fstype_info *info;
662
663 if (!dirs)
664 return;
665
666 fs_set_blk_dev_with_part(dirs->desc, dirs->part);
667 info = fs_get_info(fs_type);
668
669 info->closedir(dirs);
670 fs_close();
671}
672
AKASHI Takahiro1ba42532018-09-11 15:59:13 +0900673int fs_unlink(const char *filename)
674{
675 int ret;
676
677 struct fstype_info *info = fs_get_info(fs_type);
678
679 ret = info->unlink(filename);
680
AKASHI Takahiro1ba42532018-09-11 15:59:13 +0900681 fs_close();
682
683 return ret;
684}
AKASHI Takahiroadc8c9f2018-09-11 15:59:08 +0900685
686int fs_mkdir(const char *dirname)
687{
688 int ret;
689
690 struct fstype_info *info = fs_get_info(fs_type);
691
692 ret = info->mkdir(dirname);
693
AKASHI Takahiroadc8c9f2018-09-11 15:59:08 +0900694 fs_close();
695
696 return ret;
697}
Rob Clark2b7bfd92017-09-09 13:15:55 -0400698
Jean-Jacques Hiblotbc237482019-02-13 12:15:26 +0100699int fs_ln(const char *fname, const char *target)
700{
701 struct fstype_info *info = fs_get_info(fs_type);
702 int ret;
703
704 ret = info->ln(fname, target);
705
706 if (ret < 0) {
Heinrich Schuchardtb4559782020-08-25 17:49:16 +0000707 log_err("** Unable to create link %s -> %s **\n", fname, target);
Jean-Jacques Hiblotbc237482019-02-13 12:15:26 +0100708 ret = -1;
709 }
710 fs_close();
711
712 return ret;
713}
714
Simon Glassed38aef2020-05-10 11:40:03 -0600715int do_size(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
716 int fstype)
Stephen Warren3eb58f52014-06-11 12:47:26 -0600717{
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800718 loff_t size;
Stephen Warren3eb58f52014-06-11 12:47:26 -0600719
720 if (argc != 4)
721 return CMD_RET_USAGE;
722
723 if (fs_set_blk_dev(argv[1], argv[2], fstype))
724 return 1;
725
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800726 if (fs_size(argv[3], &size) < 0)
Stephen Warren3eb58f52014-06-11 12:47:26 -0600727 return CMD_RET_FAILURE;
728
Simon Glass4d949a22017-08-03 12:22:10 -0600729 env_set_hex("filesize", size);
Stephen Warren3eb58f52014-06-11 12:47:26 -0600730
731 return 0;
732}
733
Simon Glassed38aef2020-05-10 11:40:03 -0600734int do_load(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
735 int fstype)
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000736{
737 unsigned long addr;
738 const char *addr_str;
739 const char *filename;
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800740 loff_t bytes;
741 loff_t pos;
742 loff_t len_read;
743 int ret;
Andreas Bießmann1fd2d8a2012-11-14 13:32:37 +0100744 unsigned long time;
Pavel Machek4c1a9c52014-07-09 22:42:57 +0200745 char *ep;
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000746
Stephen Warrenb2d5cd62012-10-30 12:04:17 +0000747 if (argc < 2)
748 return CMD_RET_USAGE;
749 if (argc > 7)
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000750 return CMD_RET_USAGE;
751
Heinrich Schuchardtc556a452021-01-27 21:26:43 +0100752 if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype)) {
753 log_err("Can't set block device\n");
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000754 return 1;
Heinrich Schuchardtc556a452021-01-27 21:26:43 +0100755 }
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000756
757 if (argc >= 4) {
Simon Glass3ff49ec2021-07-24 09:03:29 -0600758 addr = hextoul(argv[3], &ep);
Pavel Machek4c1a9c52014-07-09 22:42:57 +0200759 if (ep == argv[3] || *ep != '\0')
760 return CMD_RET_USAGE;
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000761 } else {
Simon Glass64b723f2017-08-03 12:22:12 -0600762 addr_str = env_get("loadaddr");
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000763 if (addr_str != NULL)
Simon Glass3ff49ec2021-07-24 09:03:29 -0600764 addr = hextoul(addr_str, NULL);
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000765 else
766 addr = CONFIG_SYS_LOAD_ADDR;
767 }
768 if (argc >= 5) {
769 filename = argv[4];
770 } else {
Simon Glass64b723f2017-08-03 12:22:12 -0600771 filename = env_get("bootfile");
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000772 if (!filename) {
773 puts("** No boot file defined **\n");
774 return 1;
775 }
776 }
777 if (argc >= 6)
Simon Glass3ff49ec2021-07-24 09:03:29 -0600778 bytes = hextoul(argv[5], NULL);
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000779 else
780 bytes = 0;
781 if (argc >= 7)
Simon Glass3ff49ec2021-07-24 09:03:29 -0600782 pos = hextoul(argv[6], NULL);
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000783 else
784 pos = 0;
785
Andreas Bießmann1fd2d8a2012-11-14 13:32:37 +0100786 time = get_timer(0);
Simon Goldschmidt5b2c6872019-01-14 22:38:19 +0100787 ret = _fs_read(filename, addr, pos, bytes, 1, &len_read);
Andreas Bießmann1fd2d8a2012-11-14 13:32:37 +0100788 time = get_timer(time);
Heinrich Schuchardtca816ce2020-06-29 20:08:49 +0200789 if (ret < 0) {
Heinrich Schuchardtb4559782020-08-25 17:49:16 +0000790 log_err("Failed to load '%s'\n", filename);
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000791 return 1;
Heinrich Schuchardtca816ce2020-06-29 20:08:49 +0200792 }
793
794 if (IS_ENABLED(CONFIG_CMD_BOOTEFI))
795 efi_set_bootdev(argv[1], (argc > 2) ? argv[2] : "",
Heinrich Schuchardt6b821592021-01-12 12:46:24 +0100796 (argc > 4) ? argv[4] : "", map_sysmem(addr, 0),
797 len_read);
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000798
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800799 printf("%llu bytes read in %lu ms", len_read, time);
Andreas Bießmann1fd2d8a2012-11-14 13:32:37 +0100800 if (time > 0) {
801 puts(" (");
Tom Rinia17b7bc2014-11-24 11:50:46 -0500802 print_size(div_u64(len_read, time) * 1000, "/s");
Andreas Bießmann1fd2d8a2012-11-14 13:32:37 +0100803 puts(")");
804 }
805 puts("\n");
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000806
Simon Glass4d949a22017-08-03 12:22:10 -0600807 env_set_hex("fileaddr", addr);
808 env_set_hex("filesize", len_read);
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000809
810 return 0;
811}
812
Simon Glassed38aef2020-05-10 11:40:03 -0600813int do_ls(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
814 int fstype)
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000815{
816 if (argc < 2)
817 return CMD_RET_USAGE;
Stephen Warrenb2d5cd62012-10-30 12:04:17 +0000818 if (argc > 4)
819 return CMD_RET_USAGE;
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000820
821 if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
822 return 1;
823
Stephen Warrenb2d5cd62012-10-30 12:04:17 +0000824 if (fs_ls(argc >= 4 ? argv[3] : "/"))
Stephen Warreneefbc3f2012-10-22 06:43:51 +0000825 return 1;
826
827 return 0;
828}
Simon Glasseda14ea2013-04-20 08:42:50 +0000829
Stephen Warrend008fbb2014-02-03 13:21:00 -0700830int file_exists(const char *dev_type, const char *dev_part, const char *file,
831 int fstype)
832{
833 if (fs_set_blk_dev(dev_type, dev_part, fstype))
834 return 0;
835
836 return fs_exists(file);
837}
838
Simon Glassed38aef2020-05-10 11:40:03 -0600839int do_save(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
840 int fstype)
Simon Glasseda14ea2013-04-20 08:42:50 +0000841{
842 unsigned long addr;
843 const char *filename;
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800844 loff_t bytes;
845 loff_t pos;
846 loff_t len;
847 int ret;
Simon Glasseda14ea2013-04-20 08:42:50 +0000848 unsigned long time;
849
850 if (argc < 6 || argc > 7)
851 return CMD_RET_USAGE;
852
853 if (fs_set_blk_dev(argv[1], argv[2], fstype))
854 return 1;
855
Simon Glass3ff49ec2021-07-24 09:03:29 -0600856 addr = hextoul(argv[3], NULL);
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800857 filename = argv[4];
Simon Glass3ff49ec2021-07-24 09:03:29 -0600858 bytes = hextoul(argv[5], NULL);
Simon Glasseda14ea2013-04-20 08:42:50 +0000859 if (argc >= 7)
Simon Glass3ff49ec2021-07-24 09:03:29 -0600860 pos = hextoul(argv[6], NULL);
Simon Glasseda14ea2013-04-20 08:42:50 +0000861 else
862 pos = 0;
863
864 time = get_timer(0);
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800865 ret = fs_write(filename, addr, pos, bytes, &len);
Simon Glasseda14ea2013-04-20 08:42:50 +0000866 time = get_timer(time);
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800867 if (ret < 0)
Simon Glasseda14ea2013-04-20 08:42:50 +0000868 return 1;
869
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800870 printf("%llu bytes written in %lu ms", len, time);
Simon Glasseda14ea2013-04-20 08:42:50 +0000871 if (time > 0) {
872 puts(" (");
Tom Rinia17b7bc2014-11-24 11:50:46 -0500873 print_size(div_u64(len, time) * 1000, "/s");
Simon Glasseda14ea2013-04-20 08:42:50 +0000874 puts(")");
875 }
876 puts("\n");
877
878 return 0;
879}
Christian Gmeiner9f9eec32014-11-12 14:35:04 +0100880
Simon Glassed38aef2020-05-10 11:40:03 -0600881int do_fs_uuid(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
882 int fstype)
Christian Gmeiner9f9eec32014-11-12 14:35:04 +0100883{
884 int ret;
885 char uuid[37];
886 memset(uuid, 0, sizeof(uuid));
887
888 if (argc < 3 || argc > 4)
889 return CMD_RET_USAGE;
890
891 if (fs_set_blk_dev(argv[1], argv[2], fstype))
892 return 1;
893
894 ret = fs_uuid(uuid);
895 if (ret)
896 return CMD_RET_FAILURE;
897
898 if (argc == 4)
Simon Glass6a38e412017-08-03 12:22:09 -0600899 env_set(argv[3], uuid);
Christian Gmeiner9f9eec32014-11-12 14:35:04 +0100900 else
901 printf("%s\n", uuid);
902
903 return CMD_RET_SUCCESS;
904}
Sjoerd Simons7d9faf62015-01-05 18:13:36 +0100905
Simon Glassed38aef2020-05-10 11:40:03 -0600906int do_fs_type(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
Sjoerd Simons7d9faf62015-01-05 18:13:36 +0100907{
908 struct fstype_info *info;
909
910 if (argc < 3 || argc > 4)
911 return CMD_RET_USAGE;
912
913 if (fs_set_blk_dev(argv[1], argv[2], FS_TYPE_ANY))
914 return 1;
915
916 info = fs_get_info(fs_type);
917
918 if (argc == 4)
Simon Glass6a38e412017-08-03 12:22:09 -0600919 env_set(argv[3], info->name);
Sjoerd Simons7d9faf62015-01-05 18:13:36 +0100920 else
921 printf("%s\n", info->name);
922
Marek Vasut08d1c422019-02-06 13:19:29 +0100923 fs_close();
924
Sjoerd Simons7d9faf62015-01-05 18:13:36 +0100925 return CMD_RET_SUCCESS;
926}
927
Simon Glassed38aef2020-05-10 11:40:03 -0600928int do_rm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
AKASHI Takahiro1ba42532018-09-11 15:59:13 +0900929 int fstype)
930{
931 if (argc != 4)
932 return CMD_RET_USAGE;
933
934 if (fs_set_blk_dev(argv[1], argv[2], fstype))
935 return 1;
936
937 if (fs_unlink(argv[3]))
938 return 1;
939
940 return 0;
941}
942
Simon Glassed38aef2020-05-10 11:40:03 -0600943int do_mkdir(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
AKASHI Takahiroadc8c9f2018-09-11 15:59:08 +0900944 int fstype)
945{
946 int ret;
947
948 if (argc != 4)
949 return CMD_RET_USAGE;
950
951 if (fs_set_blk_dev(argv[1], argv[2], fstype))
952 return 1;
953
954 ret = fs_mkdir(argv[3]);
955 if (ret) {
Heinrich Schuchardtb4559782020-08-25 17:49:16 +0000956 log_err("** Unable to create a directory \"%s\" **\n", argv[3]);
AKASHI Takahiroadc8c9f2018-09-11 15:59:08 +0900957 return 1;
958 }
959
960 return 0;
961}
Jean-Jacques Hiblotbc237482019-02-13 12:15:26 +0100962
Simon Glassed38aef2020-05-10 11:40:03 -0600963int do_ln(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
Jean-Jacques Hiblotbc237482019-02-13 12:15:26 +0100964 int fstype)
965{
966 if (argc != 5)
967 return CMD_RET_USAGE;
968
969 if (fs_set_blk_dev(argv[1], argv[2], fstype))
970 return 1;
971
972 if (fs_ln(argv[3], argv[4]))
973 return 1;
974
975 return 0;
976}
Niel Fourie9252d702020-03-24 16:17:04 +0100977
978int do_fs_types(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[])
979{
980 struct fstype_info *drv = fstypes;
981 const int n_ents = ARRAY_SIZE(fstypes);
982 struct fstype_info *entry;
983 int i = 0;
984
985 puts("Supported filesystems");
986 for (entry = drv; entry != drv + n_ents; entry++) {
987 if (entry->fstype != FS_TYPE_ANY) {
988 printf("%c %s", i ? ',' : ':', entry->name);
989 i++;
990 }
991 }
992 if (!i)
993 puts(": <none>");
994 puts("\n");
995 return CMD_RET_SUCCESS;
996}
Simon Glasse6c49fc2023-06-01 10:22:38 -0600997
998int fs_read_alloc(const char *fname, ulong size, uint align, void **bufp)
999{
1000 loff_t bytes_read;
1001 ulong addr;
1002 char *buf;
1003 int ret;
1004
1005 buf = memalign(align, size + 1);
1006 if (!buf)
1007 return log_msg_ret("buf", -ENOMEM);
1008 addr = map_to_sysmem(buf);
1009
1010 ret = fs_read(fname, addr, 0, size, &bytes_read);
1011 if (ret) {
1012 free(buf);
1013 return log_msg_ret("read", ret);
1014 }
1015 if (size != bytes_read)
1016 return log_msg_ret("bread", -EIO);
1017 buf[size] = '\0';
1018
1019 *bufp = buf;
1020
1021 return 0;
1022}
1023
1024int fs_load_alloc(const char *ifname, const char *dev_part_str,
1025 const char *fname, ulong max_size, ulong align, void **bufp,
1026 ulong *sizep)
1027{
1028 loff_t size;
1029 void *buf;
1030 int ret;
1031
1032 if (fs_set_blk_dev(ifname, dev_part_str, FS_TYPE_ANY))
1033 return log_msg_ret("set", -ENOMEDIUM);
1034
1035 ret = fs_size(fname, &size);
1036 if (ret)
1037 return log_msg_ret("sz", -ENOENT);
1038
1039 if (size >= (max_size ?: SZ_1G))
1040 return log_msg_ret("sz", -E2BIG);
1041
1042 if (fs_set_blk_dev(ifname, dev_part_str, FS_TYPE_ANY))
1043 return log_msg_ret("set", -ENOMEDIUM);
1044
1045 ret = fs_read_alloc(fname, size, align, &buf);
1046 if (ret)
1047 return log_msg_ret("al", ret);
1048 *sizep = size;
1049 *bufp = buf;
1050
1051 return 0;
1052}