blob: 37b31d9f0fcc4d5674ce64277a1e28c0f3035712 [file] [log] [blame]
Tom Rini10e47792018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Uma Shankar71014b62012-05-25 21:21:44 +05302/*
3 * (C) Copyright 2011 - 2012 Samsung Electronics
4 * EXT4 filesystem implementation in Uboot by
5 * Uma Shankar <uma.shankar@samsung.com>
6 * Manjunatha C Achar <a.manjunatha@samsung.com>
7 *
8 * ext4ls and ext4load : Based on ext2 ls and load support in Uboot.
9 * Ext4 read optimization taken from Open-Moko
10 * Qi bootloader
11 *
12 * (C) Copyright 2004
13 * esd gmbh <www.esd-electronics.com>
14 * Reinhard Arlt <reinhard.arlt@esd-electronics.com>
15 *
16 * based on code from grub2 fs/ext2.c and fs/fshelp.c by
17 * GRUB -- GRand Unified Bootloader
18 * Copyright (C) 2003, 2004 Free Software Foundation, Inc.
19 *
Uma Shankara74a99a2012-05-25 21:22:49 +053020 * ext4write : Based on generic ext4 protocol.
Uma Shankar71014b62012-05-25 21:21:44 +053021 */
22
23#include <common.h>
Uma Shankar71014b62012-05-25 21:21:44 +053024#include <ext_common.h>
25#include <ext4fs.h>
Uma Shankar71014b62012-05-25 21:21:44 +053026#include "ext4_common.h"
Tom Rinia17b7bc2014-11-24 11:50:46 -050027#include <div64.h>
Uma Shankar71014b62012-05-25 21:21:44 +053028
29int ext4fs_symlinknest;
Rob Herring30f7fd72012-08-23 11:31:45 +000030struct ext_filesystem ext_fs;
Uma Shankar71014b62012-05-25 21:21:44 +053031
32struct ext_filesystem *get_fs(void)
33{
Rob Herring30f7fd72012-08-23 11:31:45 +000034 return &ext_fs;
Uma Shankar71014b62012-05-25 21:21:44 +053035}
36
37void ext4fs_free_node(struct ext2fs_node *node, struct ext2fs_node *currroot)
38{
39 if ((node != &ext4fs_root->diropen) && (node != currroot))
40 free(node);
41}
42
43/*
44 * Taken from openmoko-kernel mailing list: By Andy green
45 * Optimized read file API : collects and defers contiguous sector
46 * reads into one potentially more efficient larger sequential read action
47 */
Suriyan Ramasamib3a2d5a2014-11-17 14:39:36 -080048int ext4fs_read_file(struct ext2fs_node *node, loff_t pos,
49 loff_t len, char *buf, loff_t *actread)
Uma Shankar71014b62012-05-25 21:21:44 +053050{
Egbert Eich7b1b2552013-05-01 01:13:19 +000051 struct ext_filesystem *fs = get_fs();
Uma Shankar71014b62012-05-25 21:21:44 +053052 int i;
Frederic Leroye7ee0282013-06-26 18:11:25 +020053 lbaint_t blockcnt;
Egbert Eich7b1b2552013-05-01 01:13:19 +000054 int log2blksz = fs->dev_desc->log2blksz;
55 int log2_fs_blocksize = LOG2_BLOCK_SIZE(node->data) - log2blksz;
56 int blocksize = (1 << (log2_fs_blocksize + log2blksz));
Michael Wallec07cdcb2016-08-29 10:46:44 +020057 unsigned int filesize = le32_to_cpu(node->inode.size);
Frederic Leroye7ee0282013-06-26 18:11:25 +020058 lbaint_t previous_block_number = -1;
59 lbaint_t delayed_start = 0;
60 lbaint_t delayed_extent = 0;
61 lbaint_t delayed_skipfirst = 0;
62 lbaint_t delayed_next = 0;
Uma Shankar71014b62012-05-25 21:21:44 +053063 char *delayed_buf = NULL;
Paul Emge627e3c82019-07-08 16:37:07 -070064 char *start_buf = buf;
Uma Shankar71014b62012-05-25 21:21:44 +053065 short status;
Stephen Warren02d6ca72019-01-30 12:58:05 -070066 struct ext_block_cache cache;
67
68 ext_cache_init(&cache);
Uma Shankar71014b62012-05-25 21:21:44 +053069
70 /* Adjust len so it we can't read past the end of the file. */
Stefan Brünsdb5862d2016-11-06 18:33:57 +010071 if (len + pos > filesize)
72 len = (filesize - pos);
Uma Shankar71014b62012-05-25 21:21:44 +053073
Paul Emgea4a48ef2019-07-08 16:37:05 -070074 if (blocksize <= 0 || len <= 0) {
75 ext_cache_fini(&cache);
76 return -1;
77 }
78
Tom Rinia17b7bc2014-11-24 11:50:46 -050079 blockcnt = lldiv(((len + pos) + blocksize - 1), blocksize);
Uma Shankar71014b62012-05-25 21:21:44 +053080
Tom Rinia17b7bc2014-11-24 11:50:46 -050081 for (i = lldiv(pos, blocksize); i < blockcnt; i++) {
Lokesh Vutlac32ffa82017-04-26 16:58:22 +053082 long int blknr;
Tom Rinia17b7bc2014-11-24 11:50:46 -050083 int blockoff = pos - (blocksize * i);
Uma Shankar71014b62012-05-25 21:21:44 +053084 int blockend = blocksize;
85 int skipfirst = 0;
Stephen Warren02d6ca72019-01-30 12:58:05 -070086 blknr = read_allocated_block(&node->inode, i, &cache);
87 if (blknr < 0) {
88 ext_cache_fini(&cache);
Tom Riniee03bd12014-02-26 08:18:58 -050089 return -1;
Stephen Warren02d6ca72019-01-30 12:58:05 -070090 }
Uma Shankar71014b62012-05-25 21:21:44 +053091
Egbert Eich7b1b2552013-05-01 01:13:19 +000092 blknr = blknr << log2_fs_blocksize;
Uma Shankar71014b62012-05-25 21:21:44 +053093
94 /* Last block. */
95 if (i == blockcnt - 1) {
Tom Rinia17b7bc2014-11-24 11:50:46 -050096 blockend = (len + pos) - (blocksize * i);
Uma Shankar71014b62012-05-25 21:21:44 +053097
98 /* The last portion is exactly blocksize. */
99 if (!blockend)
100 blockend = blocksize;
101 }
102
103 /* First block. */
Tom Rinia17b7bc2014-11-24 11:50:46 -0500104 if (i == lldiv(pos, blocksize)) {
Uma Shankar71014b62012-05-25 21:21:44 +0530105 skipfirst = blockoff;
106 blockend -= skipfirst;
107 }
108 if (blknr) {
109 int status;
110
111 if (previous_block_number != -1) {
112 if (delayed_next == blknr) {
113 delayed_extent += blockend;
Egbert Eich7b1b2552013-05-01 01:13:19 +0000114 delayed_next += blockend >> log2blksz;
Uma Shankar71014b62012-05-25 21:21:44 +0530115 } else { /* spill */
116 status = ext4fs_devread(delayed_start,
117 delayed_skipfirst,
118 delayed_extent,
119 delayed_buf);
Stephen Warren02d6ca72019-01-30 12:58:05 -0700120 if (status == 0) {
121 ext_cache_fini(&cache);
Tom Riniee03bd12014-02-26 08:18:58 -0500122 return -1;
Stephen Warren02d6ca72019-01-30 12:58:05 -0700123 }
Uma Shankar71014b62012-05-25 21:21:44 +0530124 previous_block_number = blknr;
125 delayed_start = blknr;
126 delayed_extent = blockend;
127 delayed_skipfirst = skipfirst;
128 delayed_buf = buf;
129 delayed_next = blknr +
Egbert Eich7b1b2552013-05-01 01:13:19 +0000130 (blockend >> log2blksz);
Uma Shankar71014b62012-05-25 21:21:44 +0530131 }
132 } else {
133 previous_block_number = blknr;
134 delayed_start = blknr;
135 delayed_extent = blockend;
136 delayed_skipfirst = skipfirst;
137 delayed_buf = buf;
138 delayed_next = blknr +
Egbert Eich7b1b2552013-05-01 01:13:19 +0000139 (blockend >> log2blksz);
Uma Shankar71014b62012-05-25 21:21:44 +0530140 }
141 } else {
Ian Rayc45fcd52017-11-08 15:35:10 +0000142 int n;
Paul Emge627e3c82019-07-08 16:37:07 -0700143 int n_left;
Uma Shankar71014b62012-05-25 21:21:44 +0530144 if (previous_block_number != -1) {
145 /* spill */
146 status = ext4fs_devread(delayed_start,
147 delayed_skipfirst,
148 delayed_extent,
149 delayed_buf);
Stephen Warren02d6ca72019-01-30 12:58:05 -0700150 if (status == 0) {
151 ext_cache_fini(&cache);
Tom Riniee03bd12014-02-26 08:18:58 -0500152 return -1;
Stephen Warren02d6ca72019-01-30 12:58:05 -0700153 }
Uma Shankar71014b62012-05-25 21:21:44 +0530154 previous_block_number = -1;
155 }
Ian Rayc45fcd52017-11-08 15:35:10 +0000156 /* Zero no more than `len' bytes. */
157 n = blocksize - skipfirst;
Paul Emge627e3c82019-07-08 16:37:07 -0700158 n_left = len - ( buf - start_buf );
159 if (n > n_left)
160 n = n_left;
Ian Rayc45fcd52017-11-08 15:35:10 +0000161 memset(buf, 0, n);
Uma Shankar71014b62012-05-25 21:21:44 +0530162 }
163 buf += blocksize - skipfirst;
164 }
165 if (previous_block_number != -1) {
166 /* spill */
167 status = ext4fs_devread(delayed_start,
168 delayed_skipfirst, delayed_extent,
169 delayed_buf);
Stephen Warren02d6ca72019-01-30 12:58:05 -0700170 if (status == 0) {
171 ext_cache_fini(&cache);
Tom Riniee03bd12014-02-26 08:18:58 -0500172 return -1;
Stephen Warren02d6ca72019-01-30 12:58:05 -0700173 }
Uma Shankar71014b62012-05-25 21:21:44 +0530174 previous_block_number = -1;
175 }
176
Suriyan Ramasamib3a2d5a2014-11-17 14:39:36 -0800177 *actread = len;
Stephen Warren02d6ca72019-01-30 12:58:05 -0700178 ext_cache_fini(&cache);
Suriyan Ramasamib3a2d5a2014-11-17 14:39:36 -0800179 return 0;
Uma Shankar71014b62012-05-25 21:21:44 +0530180}
181
182int ext4fs_ls(const char *dirname)
183{
Eugen Hristevd58c8e92018-05-09 16:28:37 +0300184 struct ext2fs_node *dirnode = NULL;
Uma Shankar71014b62012-05-25 21:21:44 +0530185 int status;
186
187 if (dirname == NULL)
188 return 0;
189
190 status = ext4fs_find_file(dirname, &ext4fs_root->diropen, &dirnode,
191 FILETYPE_DIRECTORY);
192 if (status != 1) {
193 printf("** Can not find directory. **\n");
Eugen Hristevd58c8e92018-05-09 16:28:37 +0300194 if (dirnode)
195 ext4fs_free_node(dirnode, &ext4fs_root->diropen);
Uma Shankar71014b62012-05-25 21:21:44 +0530196 return 1;
197 }
198
199 ext4fs_iterate_dir(dirnode, NULL, NULL, NULL);
200 ext4fs_free_node(dirnode, &ext4fs_root->diropen);
201
202 return 0;
203}
204
Stephen Warren12d6d0c2014-02-03 13:21:09 -0700205int ext4fs_exists(const char *filename)
206{
Suriyan Ramasamib3a2d5a2014-11-17 14:39:36 -0800207 loff_t file_len;
208 int ret;
Stephen Warren12d6d0c2014-02-03 13:21:09 -0700209
Suriyan Ramasamib3a2d5a2014-11-17 14:39:36 -0800210 ret = ext4fs_open(filename, &file_len);
211 return ret == 0;
Stephen Warren12d6d0c2014-02-03 13:21:09 -0700212}
213
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800214int ext4fs_size(const char *filename, loff_t *size)
Stephen Warren3eb58f52014-06-11 12:47:26 -0600215{
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800216 return ext4fs_open(filename, size);
Stephen Warren3eb58f52014-06-11 12:47:26 -0600217}
218
Stefan Brünsdb5862d2016-11-06 18:33:57 +0100219int ext4fs_read(char *buf, loff_t offset, loff_t len, loff_t *actread)
Uma Shankar71014b62012-05-25 21:21:44 +0530220{
221 if (ext4fs_root == NULL || ext4fs_file == NULL)
Stefan Brünsdb5862d2016-11-06 18:33:57 +0100222 return -1;
Uma Shankar71014b62012-05-25 21:21:44 +0530223
Stefan Brünsdb5862d2016-11-06 18:33:57 +0100224 return ext4fs_read_file(ext4fs_file, offset, len, buf, actread);
Uma Shankar71014b62012-05-25 21:21:44 +0530225}
Simon Glass19e38582012-12-26 09:53:33 +0000226
Simon Glasse3394752016-02-29 15:25:34 -0700227int ext4fs_probe(struct blk_desc *fs_dev_desc,
Simon Glass19e38582012-12-26 09:53:33 +0000228 disk_partition_t *fs_partition)
229{
230 ext4fs_set_blk_dev(fs_dev_desc, fs_partition);
231
232 if (!ext4fs_mount(fs_partition->size)) {
233 ext4fs_close();
234 return -1;
235 }
236
237 return 0;
238}
239
Suriyan Ramasami96171fb2014-11-17 14:39:38 -0800240int ext4_read_file(const char *filename, void *buf, loff_t offset, loff_t len,
241 loff_t *len_read)
Simon Glass19e38582012-12-26 09:53:33 +0000242{
Suriyan Ramasamib3a2d5a2014-11-17 14:39:36 -0800243 loff_t file_len;
Suriyan Ramasamib3a2d5a2014-11-17 14:39:36 -0800244 int ret;
Simon Glass19e38582012-12-26 09:53:33 +0000245
Suriyan Ramasamib3a2d5a2014-11-17 14:39:36 -0800246 ret = ext4fs_open(filename, &file_len);
247 if (ret < 0) {
Simon Glass19e38582012-12-26 09:53:33 +0000248 printf("** File not found %s **\n", filename);
249 return -1;
250 }
251
252 if (len == 0)
253 len = file_len;
254
Stefan Brünsdb5862d2016-11-06 18:33:57 +0100255 return ext4fs_read(buf, offset, len, len_read);
Simon Glass19e38582012-12-26 09:53:33 +0000256}
Christian Gmeiner9f9eec32014-11-12 14:35:04 +0100257
258int ext4fs_uuid(char *uuid_str)
259{
260 if (ext4fs_root == NULL)
261 return -1;
262
263#ifdef CONFIG_LIB_UUID
264 uuid_bin_to_str((unsigned char *)ext4fs_root->sblock.unique_id,
265 uuid_str, UUID_STR_FORMAT_STD);
266
267 return 0;
268#else
269 return -ENOSYS;
270#endif
271}
Stephen Warren02d6ca72019-01-30 12:58:05 -0700272
273void ext_cache_init(struct ext_block_cache *cache)
274{
275 memset(cache, 0, sizeof(*cache));
276}
277
278void ext_cache_fini(struct ext_block_cache *cache)
279{
280 free(cache->buf);
281 ext_cache_init(cache);
282}
283
284int ext_cache_read(struct ext_block_cache *cache, lbaint_t block, int size)
285{
286 /* This could be more lenient, but this is simple and enough for now */
287 if (cache->buf && cache->block == block && cache->size == size)
288 return 1;
289 ext_cache_fini(cache);
290 cache->buf = malloc(size);
291 if (!cache->buf)
292 return 0;
293 if (!ext4fs_devread(block, 0, size, cache->buf)) {
Paul Emge955dbbc2019-07-08 16:37:04 -0700294 ext_cache_fini(cache);
Stephen Warren02d6ca72019-01-30 12:58:05 -0700295 return 0;
296 }
297 cache->block = block;
298 cache->size = size;
299 return 1;
300}