xref: /openbmc/u-boot/include/fs.h (revision 407b5b956a2e0facf6668fc8b295f4be9205c83e)
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  
10  #define FS_TYPE_ANY	0
11  #define FS_TYPE_FAT	1
12  #define FS_TYPE_EXT	2
13  #define FS_TYPE_SANDBOX	3
14  #define FS_TYPE_UBIFS	4
15  #define FS_TYPE_BTRFS	5
16  
17  /*
18   * Tell the fs layer which block device an partition to use for future
19   * commands. This also internally identifies the filesystem that is present
20   * within the partition. The identification process may be limited to a
21   * specific filesystem type by passing FS_* in the fstype parameter.
22   *
23   * Returns 0 on success.
24   * Returns non-zero if there is an error accessing the disk or partition, or
25   * no known filesystem type could be recognized on it.
26   */
27  int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype);
28  
29  /*
30   * fs_set_blk_dev_with_part - Set current block device + partition
31   *
32   * Similar to fs_set_blk_dev(), but useful for cases where you already
33   * know the blk_desc and part number.
34   *
35   * Returns 0 on success.
36   * Returns non-zero if invalid partition or error accessing the disk.
37   */
38  int fs_set_blk_dev_with_part(struct blk_desc *desc, int part);
39  
40  /**
41   * fs_get_type_name() - Get type of current filesystem
42   *
43   * Return: Pointer to filesystem name
44   *
45   * Returns a string describing the current filesystem, or the sentinel
46   * "unsupported" for any unrecognised filesystem.
47   */
48  const char *fs_get_type_name(void);
49  
50  /*
51   * Print the list of files on the partition previously set by fs_set_blk_dev(),
52   * in directory "dirname".
53   *
54   * Returns 0 on success. Returns non-zero on error.
55   */
56  int fs_ls(const char *dirname);
57  
58  /*
59   * Determine whether a file exists
60   *
61   * Returns 1 if the file exists, 0 if it doesn't exist.
62   */
63  int fs_exists(const char *filename);
64  
65  /*
66   * fs_size - Determine a file's size
67   *
68   * @filename: Name of the file
69   * @size: Size of file
70   * @return 0 if ok with valid *size, negative on error
71   */
72  int fs_size(const char *filename, loff_t *size);
73  
74  /*
75   * fs_read - Read file from the partition previously set by fs_set_blk_dev()
76   * Note that not all filesystem types support either/both offset!=0 or len!=0.
77   *
78   * @filename: Name of file to read from
79   * @addr: The address to read into
80   * @offset: The offset in file to read from
81   * @len: The number of bytes to read. Maybe 0 to read entire file
82   * @actread: Returns the actual number of bytes read
83   * @return 0 if ok with valid *actread, -1 on error conditions
84   */
85  int fs_read(const char *filename, ulong addr, loff_t offset, loff_t len,
86  	    loff_t *actread);
87  
88  /*
89   * fs_write - Write file to the partition previously set by fs_set_blk_dev()
90   * Note that not all filesystem types support offset!=0.
91   *
92   * @filename: Name of file to read from
93   * @addr: The address to read into
94   * @offset: The offset in file to read from. Maybe 0 to write to start of file
95   * @len: The number of bytes to write
96   * @actwrite: Returns the actual number of bytes written
97   * @return 0 if ok with valid *actwrite, -1 on error conditions
98   */
99  int fs_write(const char *filename, ulong addr, loff_t offset, loff_t len,
100  	     loff_t *actwrite);
101  
102  /*
103   * Directory entry types, matches the subset of DT_x in posix readdir()
104   * which apply to u-boot.
105   */
106  #define FS_DT_DIR  4         /* directory */
107  #define FS_DT_REG  8         /* regular file */
108  #define FS_DT_LNK  10        /* symbolic link */
109  
110  /*
111   * A directory entry, returned by fs_readdir().  Returns information
112   * about the file/directory at the current directory entry position.
113   */
114  struct fs_dirent {
115  	unsigned type;       /* one of FS_DT_x (not a mask) */
116  	loff_t size;         /* size in bytes */
117  	char name[256];
118  };
119  
120  /* Note: fs_dir_stream should be treated as opaque to the user of fs layer */
121  struct fs_dir_stream {
122  	/* private to fs. layer: */
123  	struct blk_desc *desc;
124  	int part;
125  };
126  
127  /*
128   * fs_opendir - Open a directory
129   *
130   * @filename: the path to directory to open
131   * @return a pointer to the directory stream or NULL on error and errno
132   *    set appropriately
133   */
134  struct fs_dir_stream *fs_opendir(const char *filename);
135  
136  /*
137   * fs_readdir - Read the next directory entry in the directory stream.
138   *
139   * Works in an analogous way to posix readdir().  The previously returned
140   * directory entry is no longer valid after calling fs_readdir() again.
141   * After fs_closedir() is called, the returned directory entry is no
142   * longer valid.
143   *
144   * @dirs: the directory stream
145   * @return the next directory entry (only valid until next fs_readdir() or
146   *    fs_closedir() call, do not attempt to free()) or NULL if the end of
147   *    the directory is reached.
148   */
149  struct fs_dirent *fs_readdir(struct fs_dir_stream *dirs);
150  
151  /*
152   * fs_closedir - close a directory stream
153   *
154   * @dirs: the directory stream
155   */
156  void fs_closedir(struct fs_dir_stream *dirs);
157  
158  /*
159   * fs_unlink - delete a file or directory
160   *
161   * If a given name is a directory, it will be deleted only if it's empty
162   *
163   * @filename: Name of file or directory to delete
164   * @return 0 on success, -1 on error conditions
165   */
166  int fs_unlink(const char *filename);
167  
168  /*
169   * fs_mkdir - Create a directory
170   *
171   * @filename: Name of directory to create
172   * @return 0 on success, -1 on error conditions
173   */
174  int fs_mkdir(const char *filename);
175  
176  /*
177   * Common implementation for various filesystem commands, optionally limited
178   * to a specific filesystem type via the fstype parameter.
179   */
180  int do_size(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
181  		int fstype);
182  int do_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
183  		int fstype);
184  int do_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
185  		int fstype);
186  int file_exists(const char *dev_type, const char *dev_part, const char *file,
187  		int fstype);
188  int do_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
189  		int fstype);
190  int do_rm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
191  		int fstype);
192  int do_mkdir(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
193  		int fstype);
194  
195  /*
196   * Determine the UUID of the specified filesystem and print it. Optionally it is
197   * possible to store the UUID directly in env.
198   */
199  int do_fs_uuid(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
200  		int fstype);
201  
202  /*
203   * Determine the type of the specified filesystem and print it. Optionally it is
204   * possible to store the type directly in env.
205   */
206  int do_fs_type(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
207  
208  #endif /* _FS_H */
209