1 /*
2 * (C) Copyright 2011 - 2012 Samsung Electronics
3 * EXT4 filesystem implementation in Uboot by
4 * Uma Shankar <uma.shankar@samsung.com>
5 * Manjunatha C Achar <a.manjunatha@samsung.com>
6 *
7 * ext4ls and ext4load : Based on ext2 ls and load support in Uboot.
8 * Ext4 read optimization taken from Open-Moko
9 * Qi bootloader
10 *
11 * (C) Copyright 2004
12 * esd gmbh <www.esd-electronics.com>
13 * Reinhard Arlt <reinhard.arlt@esd-electronics.com>
14 *
15 * based on code from grub2 fs/ext2.c and fs/fshelp.c by
16 * GRUB -- GRand Unified Bootloader
17 * Copyright (C) 2003, 2004 Free Software Foundation, Inc.
18 *
19 * ext4write : Based on generic ext4 protocol.
20 *
21 * SPDX-License-Identifier: GPL-2.0+
22 */
23
24 #include <common.h>
25 #include <ext_common.h>
26 #include <ext4fs.h>
27 #include "ext4_common.h"
28 #include <div64.h>
29
30 int ext4fs_symlinknest;
31 struct ext_filesystem ext_fs;
32
get_fs(void)33 struct ext_filesystem *get_fs(void)
34 {
35 return &ext_fs;
36 }
37
ext4fs_free_node(struct ext2fs_node * node,struct ext2fs_node * currroot)38 void ext4fs_free_node(struct ext2fs_node *node, struct ext2fs_node *currroot)
39 {
40 if ((node != &ext4fs_root->diropen) && (node != currroot))
41 free(node);
42 }
43
44 /*
45 * Taken from openmoko-kernel mailing list: By Andy green
46 * Optimized read file API : collects and defers contiguous sector
47 * reads into one potentially more efficient larger sequential read action
48 */
ext4fs_read_file(struct ext2fs_node * node,loff_t pos,loff_t len,char * buf,loff_t * actread)49 int ext4fs_read_file(struct ext2fs_node *node, loff_t pos,
50 loff_t len, char *buf, loff_t *actread)
51 {
52 struct ext_filesystem *fs = get_fs();
53 int i;
54 lbaint_t blockcnt;
55 int log2blksz = fs->dev_desc->log2blksz;
56 int log2_fs_blocksize = LOG2_BLOCK_SIZE(node->data) - log2blksz;
57 int blocksize = (1 << (log2_fs_blocksize + log2blksz));
58 unsigned int filesize = le32_to_cpu(node->inode.size);
59 lbaint_t previous_block_number = -1;
60 lbaint_t delayed_start = 0;
61 lbaint_t delayed_extent = 0;
62 lbaint_t delayed_skipfirst = 0;
63 lbaint_t delayed_next = 0;
64 char *delayed_buf = NULL;
65 short status;
66
67 if (blocksize <= 0)
68 return -1;
69
70 /* Adjust len so it we can't read past the end of the file. */
71 if (len + pos > filesize)
72 len = (filesize - pos);
73
74 blockcnt = lldiv(((len + pos) + blocksize - 1), blocksize);
75
76 for (i = lldiv(pos, blocksize); i < blockcnt; i++) {
77 long int blknr;
78 int blockoff = pos - (blocksize * i);
79 int blockend = blocksize;
80 int skipfirst = 0;
81 blknr = read_allocated_block(&(node->inode), i);
82 if (blknr < 0)
83 return -1;
84
85 blknr = blknr << log2_fs_blocksize;
86
87 /* Last block. */
88 if (i == blockcnt - 1) {
89 blockend = (len + pos) - (blocksize * i);
90
91 /* The last portion is exactly blocksize. */
92 if (!blockend)
93 blockend = blocksize;
94 }
95
96 /* First block. */
97 if (i == lldiv(pos, blocksize)) {
98 skipfirst = blockoff;
99 blockend -= skipfirst;
100 }
101 if (blknr) {
102 int status;
103
104 if (previous_block_number != -1) {
105 if (delayed_next == blknr) {
106 delayed_extent += blockend;
107 delayed_next += blockend >> log2blksz;
108 } else { /* spill */
109 status = ext4fs_devread(delayed_start,
110 delayed_skipfirst,
111 delayed_extent,
112 delayed_buf);
113 if (status == 0)
114 return -1;
115 previous_block_number = blknr;
116 delayed_start = blknr;
117 delayed_extent = blockend;
118 delayed_skipfirst = skipfirst;
119 delayed_buf = buf;
120 delayed_next = blknr +
121 (blockend >> log2blksz);
122 }
123 } else {
124 previous_block_number = blknr;
125 delayed_start = blknr;
126 delayed_extent = blockend;
127 delayed_skipfirst = skipfirst;
128 delayed_buf = buf;
129 delayed_next = blknr +
130 (blockend >> log2blksz);
131 }
132 } else {
133 int n;
134 if (previous_block_number != -1) {
135 /* spill */
136 status = ext4fs_devread(delayed_start,
137 delayed_skipfirst,
138 delayed_extent,
139 delayed_buf);
140 if (status == 0)
141 return -1;
142 previous_block_number = -1;
143 }
144 /* Zero no more than `len' bytes. */
145 n = blocksize - skipfirst;
146 if (n > len)
147 n = len;
148 memset(buf, 0, n);
149 }
150 buf += blocksize - skipfirst;
151 }
152 if (previous_block_number != -1) {
153 /* spill */
154 status = ext4fs_devread(delayed_start,
155 delayed_skipfirst, delayed_extent,
156 delayed_buf);
157 if (status == 0)
158 return -1;
159 previous_block_number = -1;
160 }
161
162 *actread = len;
163 return 0;
164 }
165
ext4fs_ls(const char * dirname)166 int ext4fs_ls(const char *dirname)
167 {
168 struct ext2fs_node *dirnode;
169 int status;
170
171 if (dirname == NULL)
172 return 0;
173
174 status = ext4fs_find_file(dirname, &ext4fs_root->diropen, &dirnode,
175 FILETYPE_DIRECTORY);
176 if (status != 1) {
177 printf("** Can not find directory. **\n");
178 ext4fs_free_node(dirnode, &ext4fs_root->diropen);
179 return 1;
180 }
181
182 ext4fs_iterate_dir(dirnode, NULL, NULL, NULL);
183 ext4fs_free_node(dirnode, &ext4fs_root->diropen);
184
185 return 0;
186 }
187
ext4fs_exists(const char * filename)188 int ext4fs_exists(const char *filename)
189 {
190 loff_t file_len;
191 int ret;
192
193 ret = ext4fs_open(filename, &file_len);
194 return ret == 0;
195 }
196
ext4fs_size(const char * filename,loff_t * size)197 int ext4fs_size(const char *filename, loff_t *size)
198 {
199 return ext4fs_open(filename, size);
200 }
201
ext4fs_read(char * buf,loff_t offset,loff_t len,loff_t * actread)202 int ext4fs_read(char *buf, loff_t offset, loff_t len, loff_t *actread)
203 {
204 if (ext4fs_root == NULL || ext4fs_file == NULL)
205 return -1;
206
207 return ext4fs_read_file(ext4fs_file, offset, len, buf, actread);
208 }
209
ext4fs_probe(struct blk_desc * fs_dev_desc,disk_partition_t * fs_partition)210 int ext4fs_probe(struct blk_desc *fs_dev_desc,
211 disk_partition_t *fs_partition)
212 {
213 ext4fs_set_blk_dev(fs_dev_desc, fs_partition);
214
215 if (!ext4fs_mount(fs_partition->size)) {
216 ext4fs_close();
217 return -1;
218 }
219
220 return 0;
221 }
222
ext4_read_file(const char * filename,void * buf,loff_t offset,loff_t len,loff_t * len_read)223 int ext4_read_file(const char *filename, void *buf, loff_t offset, loff_t len,
224 loff_t *len_read)
225 {
226 loff_t file_len;
227 int ret;
228
229 ret = ext4fs_open(filename, &file_len);
230 if (ret < 0) {
231 printf("** File not found %s **\n", filename);
232 return -1;
233 }
234
235 if (len == 0)
236 len = file_len;
237
238 return ext4fs_read(buf, offset, len, len_read);
239 }
240
ext4fs_uuid(char * uuid_str)241 int ext4fs_uuid(char *uuid_str)
242 {
243 if (ext4fs_root == NULL)
244 return -1;
245
246 #ifdef CONFIG_LIB_UUID
247 uuid_bin_to_str((unsigned char *)ext4fs_root->sblock.unique_id,
248 uuid_str, UUID_STR_FORMAT_STD);
249
250 return 0;
251 #else
252 return -ENOSYS;
253 #endif
254 }
255