1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved. 4 */ 5 #ifndef _FS_H 6 #define _FS_H 7 8 #include <common.h> 9 #include <rtc.h> 10 11 struct cmd_tbl; 12 13 #define FS_TYPE_ANY 0 14 #define FS_TYPE_FAT 1 15 #define FS_TYPE_EXT 2 16 #define FS_TYPE_SANDBOX 3 17 #define FS_TYPE_UBIFS 4 18 #define FS_TYPE_BTRFS 5 19 #define FS_TYPE_SQUASHFS 6 20 21 struct blk_desc; 22 23 /** 24 * do_fat_fsload - Run the fatload command 25 * 26 * @cmdtp: Command information for fatload 27 * @flag: Command flags (CMD_FLAG_...) 28 * @argc: Number of arguments 29 * @argv: List of arguments 30 * @return result (see enum command_ret_t) 31 */ 32 int do_fat_fsload(struct cmd_tbl *cmdtp, int flag, int argc, 33 char *const argv[]); 34 35 /** 36 * do_ext2load - Run the ext2load command 37 * 38 * @cmdtp: Command information for ext2load 39 * @flag: Command flags (CMD_FLAG_...) 40 * @argc: Number of arguments 41 * @argv: List of arguments 42 * @return result (see enum command_ret_t) 43 */ 44 int do_ext2load(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]); 45 46 /* 47 * Tell the fs layer which block device an partition to use for future 48 * commands. This also internally identifies the filesystem that is present 49 * within the partition. The identification process may be limited to a 50 * specific filesystem type by passing FS_* in the fstype parameter. 51 * 52 * Returns 0 on success. 53 * Returns non-zero if there is an error accessing the disk or partition, or 54 * no known filesystem type could be recognized on it. 55 */ 56 int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype); 57 58 /* 59 * fs_set_blk_dev_with_part - Set current block device + partition 60 * 61 * Similar to fs_set_blk_dev(), but useful for cases where you already 62 * know the blk_desc and part number. 63 * 64 * Returns 0 on success. 65 * Returns non-zero if invalid partition or error accessing the disk. 66 */ 67 int fs_set_blk_dev_with_part(struct blk_desc *desc, int part); 68 69 /** 70 * fs_close() - Unset current block device and partition 71 * 72 * fs_close() closes the connection to a file system opened with either 73 * fs_set_blk_dev() or fs_set_dev_with_part(). 74 * 75 * Many file functions implicitly call fs_close(), e.g. fs_closedir(), 76 * fs_exist(), fs_ln(), fs_ls(), fs_mkdir(), fs_read(), fs_size(), fs_write(), 77 * fs_unlink(). 78 */ 79 void fs_close(void); 80 81 /** 82 * fs_get_type() - Get type of current filesystem 83 * 84 * Return: filesystem type 85 * 86 * Returns filesystem type representing the current filesystem, or 87 * FS_TYPE_ANY for any unrecognised filesystem. 88 */ 89 int fs_get_type(void); 90 91 /** 92 * fs_get_type_name() - Get type of current filesystem 93 * 94 * Return: Pointer to filesystem name 95 * 96 * Returns a string describing the current filesystem, or the sentinel 97 * "unsupported" for any unrecognised filesystem. 98 */ 99 const char *fs_get_type_name(void); 100 101 /* 102 * Print the list of files on the partition previously set by fs_set_blk_dev(), 103 * in directory "dirname". 104 * 105 * Returns 0 on success. Returns non-zero on error. 106 */ 107 int fs_ls(const char *dirname); 108 109 /* 110 * Determine whether a file exists 111 * 112 * Returns 1 if the file exists, 0 if it doesn't exist. 113 */ 114 int fs_exists(const char *filename); 115 116 /* 117 * fs_size - Determine a file's size 118 * 119 * @filename: Name of the file 120 * @size: Size of file 121 * @return 0 if ok with valid *size, negative on error 122 */ 123 int fs_size(const char *filename, loff_t *size); 124 125 /** 126 * fs_read() - read file from the partition previously set by fs_set_blk_dev() 127 * 128 * Note that not all filesystem drivers support either or both of offset != 0 129 * and len != 0. 130 * 131 * @filename: full path of the file to read from 132 * @addr: address of the buffer to write to 133 * @offset: offset in the file from where to start reading 134 * @len: the number of bytes to read. Use 0 to read entire file. 135 * @actread: returns the actual number of bytes read 136 * Return: 0 if OK with valid *actread, -1 on error conditions 137 */ 138 int fs_read(const char *filename, ulong addr, loff_t offset, loff_t len, 139 loff_t *actread); 140 141 /** 142 * fs_write() - write file to the partition previously set by fs_set_blk_dev() 143 * 144 * Note that not all filesystem drivers support offset != 0. 145 * 146 * @filename: full path of the file to write to 147 * @addr: address of the buffer to read from 148 * @offset: offset in the file from where to start writing 149 * @len: the number of bytes to write 150 * @actwrite: returns the actual number of bytes written 151 * Return: 0 if OK with valid *actwrite, -1 on error conditions 152 */ 153 int fs_write(const char *filename, ulong addr, loff_t offset, loff_t len, 154 loff_t *actwrite); 155 156 /* 157 * Directory entry types, matches the subset of DT_x in posix readdir() 158 * which apply to u-boot. 159 */ 160 #define FS_DT_DIR 4 /* directory */ 161 #define FS_DT_REG 8 /* regular file */ 162 #define FS_DT_LNK 10 /* symbolic link */ 163 164 /** 165 * struct fs_dirent - directory entry 166 * 167 * A directory entry, returned by fs_readdir(). Returns information 168 * about the file/directory at the current directory entry position. 169 */ 170 struct fs_dirent { 171 /** @type: one of FS_DT_x (not a mask) */ 172 unsigned int type; 173 /** @size: file size */ 174 loff_t size; 175 /** @flags: attribute flags (FS_ATTR_*) */ 176 u32 attr; 177 /** create_time: time of creation */ 178 struct rtc_time create_time; 179 /** access_time: time of last access */ 180 struct rtc_time access_time; 181 /** change_time: time of last modification */ 182 struct rtc_time change_time; 183 /** name: file name */ 184 char name[256]; 185 }; 186 187 /* Note: fs_dir_stream should be treated as opaque to the user of fs layer */ 188 struct fs_dir_stream { 189 /* private to fs. layer: */ 190 struct blk_desc *desc; 191 int part; 192 }; 193 194 /* 195 * fs_opendir - Open a directory 196 * 197 * @filename: the path to directory to open 198 * @return a pointer to the directory stream or NULL on error and errno 199 * set appropriately 200 */ 201 struct fs_dir_stream *fs_opendir(const char *filename); 202 203 /* 204 * fs_readdir - Read the next directory entry in the directory stream. 205 * 206 * Works in an analogous way to posix readdir(). The previously returned 207 * directory entry is no longer valid after calling fs_readdir() again. 208 * After fs_closedir() is called, the returned directory entry is no 209 * longer valid. 210 * 211 * @dirs: the directory stream 212 * @return the next directory entry (only valid until next fs_readdir() or 213 * fs_closedir() call, do not attempt to free()) or NULL if the end of 214 * the directory is reached. 215 */ 216 struct fs_dirent *fs_readdir(struct fs_dir_stream *dirs); 217 218 /* 219 * fs_closedir - close a directory stream 220 * 221 * @dirs: the directory stream 222 */ 223 void fs_closedir(struct fs_dir_stream *dirs); 224 225 /* 226 * fs_unlink - delete a file or directory 227 * 228 * If a given name is a directory, it will be deleted only if it's empty 229 * 230 * @filename: Name of file or directory to delete 231 * @return 0 on success, -1 on error conditions 232 */ 233 int fs_unlink(const char *filename); 234 235 /* 236 * fs_mkdir - Create a directory 237 * 238 * @filename: Name of directory to create 239 * @return 0 on success, -1 on error conditions 240 */ 241 int fs_mkdir(const char *filename); 242 243 /* 244 * Common implementation for various filesystem commands, optionally limited 245 * to a specific filesystem type via the fstype parameter. 246 */ 247 int do_size(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[], 248 int fstype); 249 int do_load(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[], 250 int fstype); 251 int do_ls(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[], 252 int fstype); 253 int file_exists(const char *dev_type, const char *dev_part, const char *file, 254 int fstype); 255 int do_save(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[], 256 int fstype); 257 int do_rm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[], 258 int fstype); 259 int do_mkdir(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[], 260 int fstype); 261 int do_ln(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[], 262 int fstype); 263 264 /* 265 * Determine the UUID of the specified filesystem and print it. Optionally it is 266 * possible to store the UUID directly in env. 267 */ 268 int do_fs_uuid(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[], 269 int fstype); 270 271 /* 272 * Determine the type of the specified filesystem and print it. Optionally it is 273 * possible to store the type directly in env. 274 */ 275 int do_fs_type(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]); 276 277 /** 278 * do_fs_types - List supported filesystems. 279 * 280 * @cmdtp: Command information for fstypes 281 * @flag: Command flags (CMD_FLAG_...) 282 * @argc: Number of arguments 283 * @argv: List of arguments 284 * @return result (see enum command_ret_t) 285 */ 286 int do_fs_types(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[]); 287 288 #endif /* _FS_H */ 289