]> git.sur5r.net Git - u-boot/blob - fs/btrfs/btrfs.c
Merge branch 'master' of git://git.denx.de/u-boot-usb
[u-boot] / fs / btrfs / btrfs.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * BTRFS filesystem implementation for U-Boot
4  *
5  * 2017 Marek Behun, CZ.NIC, marek.behun@nic.cz
6  */
7
8 #include "btrfs.h"
9 #include <config.h>
10 #include <malloc.h>
11 #include <linux/time.h>
12
13 struct btrfs_info btrfs_info;
14
15 static int readdir_callback(const struct btrfs_root *root,
16                             struct btrfs_dir_item *item)
17 {
18         static const char typestr[BTRFS_FT_MAX][4] = {
19                 [BTRFS_FT_UNKNOWN]  = " ? ",
20                 [BTRFS_FT_REG_FILE] = "   ",
21                 [BTRFS_FT_DIR]      = "DIR",
22                 [BTRFS_FT_CHRDEV]   = "CHR",
23                 [BTRFS_FT_BLKDEV]   = "BLK",
24                 [BTRFS_FT_FIFO]     = "FIF",
25                 [BTRFS_FT_SOCK]     = "SCK",
26                 [BTRFS_FT_SYMLINK]  = "SYM",
27                 [BTRFS_FT_XATTR]    = " ? ",
28         };
29         struct btrfs_inode_item inode;
30         const char *name = (const char *) (item + 1);
31         char filetime[32], *target = NULL;
32         time_t mtime;
33
34         if (btrfs_lookup_inode(root, &item->location, &inode, NULL)) {
35                 printf("%s: Cannot find inode item for directory entry %.*s!\n",
36                        __func__, item->name_len, name);
37                 return 0;
38         }
39
40         mtime = inode.mtime.sec;
41         ctime_r(&mtime, filetime);
42
43         if (item->type == BTRFS_FT_SYMLINK) {
44                 target = malloc(min(inode.size + 1,
45                                     (u64) btrfs_info.sb.sectorsize));
46
47                 if (target && btrfs_readlink(root, item->location.objectid,
48                                              target)) {
49                         free(target);
50                         target = NULL;
51                 }
52
53                 if (!target)
54                         printf("%s: Cannot read symlink target!\n", __func__);
55         }
56
57         printf("<%s> ", typestr[item->type]);
58         if (item->type == BTRFS_FT_CHRDEV || item->type == BTRFS_FT_BLKDEV)
59                 printf("%4u,%5u  ", (unsigned int) (inode.rdev >> 20),
60                         (unsigned int) (inode.rdev & 0xfffff));
61         else
62                 printf("%10llu  ", inode.size);
63
64         printf("%24.24s  %.*s", filetime, item->name_len, name);
65
66         if (item->type == BTRFS_FT_SYMLINK) {
67                 printf(" -> %s", target ? target : "?");
68                 if (target)
69                         free(target);
70         }
71
72         printf("\n");
73
74         return 0;
75 }
76
77 int btrfs_probe(struct blk_desc *fs_dev_desc, disk_partition_t *fs_partition)
78 {
79         btrfs_blk_desc = fs_dev_desc;
80         btrfs_part_info = fs_partition;
81
82         memset(&btrfs_info, 0, sizeof(btrfs_info));
83
84         btrfs_hash_init();
85         if (btrfs_read_superblock())
86                 return -1;
87
88         if (btrfs_chunk_map_init()) {
89                 printf("%s: failed to init chunk map\n", __func__);
90                 return -1;
91         }
92
93         btrfs_info.tree_root.objectid = 0;
94         btrfs_info.tree_root.bytenr = btrfs_info.sb.root;
95         btrfs_info.chunk_root.objectid = 0;
96         btrfs_info.chunk_root.bytenr = btrfs_info.sb.chunk_root;
97
98         if (btrfs_read_chunk_tree()) {
99                 printf("%s: failed to read chunk tree\n", __func__);
100                 return -1;
101         }
102
103         if (btrfs_find_root(btrfs_get_default_subvol_objectid(),
104                             &btrfs_info.fs_root, NULL)) {
105                 printf("%s: failed to find default subvolume\n", __func__);
106                 return -1;
107         }
108
109         return 0;
110 }
111
112 int btrfs_ls(const char *path)
113 {
114         struct btrfs_root root = btrfs_info.fs_root;
115         u64 inr;
116         u8 type;
117
118         inr = btrfs_lookup_path(&root, root.root_dirid, path, &type, NULL, 40);
119
120         if (inr == -1ULL) {
121                 printf("Cannot lookup path %s\n", path);
122                 return 1;
123         }
124
125         if (type != BTRFS_FT_DIR) {
126                 printf("Not a directory: %s\n", path);
127                 return 1;
128         }
129
130         if (btrfs_readdir(&root, inr, readdir_callback)) {
131                 printf("An error occured while listing directory %s\n", path);
132                 return 1;
133         }
134
135         return 0;
136 }
137
138 int btrfs_exists(const char *file)
139 {
140         struct btrfs_root root = btrfs_info.fs_root;
141         u64 inr;
142         u8 type;
143
144         inr = btrfs_lookup_path(&root, root.root_dirid, file, &type, NULL, 40);
145
146         return (inr != -1ULL && type == BTRFS_FT_REG_FILE);
147 }
148
149 int btrfs_size(const char *file, loff_t *size)
150 {
151         struct btrfs_root root = btrfs_info.fs_root;
152         struct btrfs_inode_item inode;
153         u64 inr;
154         u8 type;
155
156         inr = btrfs_lookup_path(&root, root.root_dirid, file, &type, &inode,
157                                 40);
158
159         if (inr == -1ULL) {
160                 printf("Cannot lookup file %s\n", file);
161                 return 1;
162         }
163
164         if (type != BTRFS_FT_REG_FILE) {
165                 printf("Not a regular file: %s\n", file);
166                 return 1;
167         }
168
169         *size = inode.size;
170         return 0;
171 }
172
173 int btrfs_read(const char *file, void *buf, loff_t offset, loff_t len,
174                loff_t *actread)
175 {
176         struct btrfs_root root = btrfs_info.fs_root;
177         struct btrfs_inode_item inode;
178         u64 inr, rd;
179         u8 type;
180
181         inr = btrfs_lookup_path(&root, root.root_dirid, file, &type, &inode,
182                                 40);
183
184         if (inr == -1ULL) {
185                 printf("Cannot lookup file %s\n", file);
186                 return 1;
187         }
188
189         if (type != BTRFS_FT_REG_FILE) {
190                 printf("Not a regular file: %s\n", file);
191                 return 1;
192         }
193
194         if (!len)
195                 len = inode.size;
196
197         if (len > inode.size - offset)
198                 len = inode.size - offset;
199
200         rd = btrfs_file_read(&root, inr, offset, len, buf);
201         if (rd == -1ULL) {
202                 printf("An error occured while reading file %s\n", file);
203                 return 1;
204         }
205
206         *actread = rd;
207         return 0;
208 }
209
210 void btrfs_close(void)
211 {
212         btrfs_chunk_map_exit();
213 }
214
215 int btrfs_uuid(char *uuid_str)
216 {
217 #ifdef CONFIG_LIB_UUID
218         uuid_bin_to_str(btrfs_info.sb.fsid, uuid_str, UUID_STR_FORMAT_STD);
219         return 0;
220 #endif
221         return -ENOSYS;
222 }