1 // SPDX-License-Identifier: GPL-2.0+
2 /*
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 *
20 * ext4write : Based on generic ext4 protocol.
21 */
22
23
24 #include <common.h>
25 #include <blk.h>
26 #include <log.h>
27 #include <malloc.h>
28 #include <memalign.h>
29 #include <part.h>
30 #include <linux/stat.h>
31 #include <div64.h>
32 #include "ext4_common.h"
33
ext4fs_sb_free_inodes_inc(struct ext2_sblock * sb)34 static inline void ext4fs_sb_free_inodes_inc(struct ext2_sblock *sb)
35 {
36 sb->free_inodes = cpu_to_le32(le32_to_cpu(sb->free_inodes) + 1);
37 }
38
ext4fs_sb_free_blocks_inc(struct ext2_sblock * sb)39 static inline void ext4fs_sb_free_blocks_inc(struct ext2_sblock *sb)
40 {
41 sb->free_blocks = cpu_to_le32(le32_to_cpu(sb->free_blocks) + 1);
42 }
43
ext4fs_bg_free_inodes_inc(struct ext2_block_group * bg,const struct ext_filesystem * fs)44 static inline void ext4fs_bg_free_inodes_inc
45 (struct ext2_block_group *bg, const struct ext_filesystem *fs)
46 {
47 uint32_t free_inodes = le16_to_cpu(bg->free_inodes);
48 if (fs->gdsize == 64)
49 free_inodes += le16_to_cpu(bg->free_inodes_high) << 16;
50 free_inodes++;
51
52 bg->free_inodes = cpu_to_le16(free_inodes & 0xffff);
53 if (fs->gdsize == 64)
54 bg->free_inodes_high = cpu_to_le16(free_inodes >> 16);
55 }
56
ext4fs_bg_free_blocks_inc(struct ext2_block_group * bg,const struct ext_filesystem * fs)57 static inline void ext4fs_bg_free_blocks_inc
58 (struct ext2_block_group *bg, const struct ext_filesystem *fs)
59 {
60 uint32_t free_blocks = le16_to_cpu(bg->free_blocks);
61 if (fs->gdsize == 64)
62 free_blocks += le16_to_cpu(bg->free_blocks_high) << 16;
63 free_blocks++;
64
65 bg->free_blocks = cpu_to_le16(free_blocks & 0xffff);
66 if (fs->gdsize == 64)
67 bg->free_blocks_high = cpu_to_le16(free_blocks >> 16);
68 }
69
ext4fs_update(void)70 static void ext4fs_update(void)
71 {
72 short i;
73 ext4fs_update_journal();
74 struct ext_filesystem *fs = get_fs();
75 struct ext2_block_group *bgd = NULL;
76
77 /* update super block */
78 put_ext4((uint64_t)(SUPERBLOCK_SIZE),
79 (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE);
80
81 /* update block bitmaps */
82 for (i = 0; i < fs->no_blkgrp; i++) {
83 bgd = ext4fs_get_group_descriptor(fs, i);
84 bgd->bg_checksum = cpu_to_le16(ext4fs_checksum_update(i));
85 uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs);
86 put_ext4(b_bitmap_blk * fs->blksz,
87 fs->blk_bmaps[i], fs->blksz);
88 }
89
90 /* update inode bitmaps */
91 for (i = 0; i < fs->no_blkgrp; i++) {
92 bgd = ext4fs_get_group_descriptor(fs, i);
93 uint64_t i_bitmap_blk = ext4fs_bg_get_inode_id(bgd, fs);
94 put_ext4(i_bitmap_blk * fs->blksz,
95 fs->inode_bmaps[i], fs->blksz);
96 }
97
98 /* update the block group descriptor table */
99 put_ext4((uint64_t)((uint64_t)fs->gdtable_blkno * (uint64_t)fs->blksz),
100 (struct ext2_block_group *)fs->gdtable,
101 (fs->blksz * fs->no_blk_pergdt));
102
103 ext4fs_dump_metadata();
104
105 gindex = 0;
106 gd_index = 0;
107 }
108
ext4fs_get_bgdtable(void)109 int ext4fs_get_bgdtable(void)
110 {
111 int status;
112 struct ext_filesystem *fs = get_fs();
113 int gdsize_total = ROUND(fs->no_blkgrp * fs->gdsize, fs->blksz);
114 fs->no_blk_pergdt = gdsize_total / fs->blksz;
115
116 /* allocate memory for gdtable */
117 fs->gdtable = zalloc(gdsize_total);
118 if (!fs->gdtable)
119 return -ENOMEM;
120 /* read the group descriptor table */
121 status = ext4fs_devread((lbaint_t)fs->gdtable_blkno * fs->sect_perblk,
122 0, fs->blksz * fs->no_blk_pergdt, fs->gdtable);
123 if (status == 0)
124 goto fail;
125
126 if (ext4fs_log_gdt(fs->gdtable)) {
127 printf("Error in ext4fs_log_gdt\n");
128 return -1;
129 }
130
131 return 0;
132 fail:
133 free(fs->gdtable);
134 fs->gdtable = NULL;
135
136 return -1;
137 }
138
delete_single_indirect_block(struct ext2_inode * inode)139 static void delete_single_indirect_block(struct ext2_inode *inode)
140 {
141 struct ext2_block_group *bgd = NULL;
142 static int prev_bg_bmap_idx = -1;
143 uint32_t blknr;
144 int remainder;
145 int bg_idx;
146 int status;
147 uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group);
148 struct ext_filesystem *fs = get_fs();
149 char *journal_buffer = zalloc(fs->blksz);
150 if (!journal_buffer) {
151 printf("No memory\n");
152 return;
153 }
154
155 /* deleting the single indirect block associated with inode */
156 if (inode->b.blocks.indir_block != 0) {
157 blknr = le32_to_cpu(inode->b.blocks.indir_block);
158 debug("SIPB releasing %u\n", blknr);
159 bg_idx = blknr / blk_per_grp;
160 if (fs->blksz == 1024) {
161 remainder = blknr % blk_per_grp;
162 if (!remainder)
163 bg_idx--;
164 }
165 ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
166 /* get block group descriptor table */
167 bgd = ext4fs_get_group_descriptor(fs, bg_idx);
168 ext4fs_bg_free_blocks_inc(bgd, fs);
169 ext4fs_sb_free_blocks_inc(fs->sb);
170 /* journal backup */
171 if (prev_bg_bmap_idx != bg_idx) {
172 uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs);
173 status = ext4fs_devread(
174 b_bitmap_blk * fs->sect_perblk,
175 0, fs->blksz, journal_buffer);
176 if (status == 0)
177 goto fail;
178 if (ext4fs_log_journal(journal_buffer, b_bitmap_blk))
179 goto fail;
180 prev_bg_bmap_idx = bg_idx;
181 }
182 }
183 fail:
184 free(journal_buffer);
185 }
186
delete_double_indirect_block(struct ext2_inode * inode)187 static void delete_double_indirect_block(struct ext2_inode *inode)
188 {
189 int i;
190 short status;
191 static int prev_bg_bmap_idx = -1;
192 uint32_t blknr;
193 int remainder;
194 int bg_idx;
195 uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group);
196 __le32 *di_buffer = NULL;
197 void *dib_start_addr = NULL;
198 struct ext2_block_group *bgd = NULL;
199 struct ext_filesystem *fs = get_fs();
200 char *journal_buffer = zalloc(fs->blksz);
201 if (!journal_buffer) {
202 printf("No memory\n");
203 return;
204 }
205
206 if (inode->b.blocks.double_indir_block != 0) {
207 di_buffer = zalloc(fs->blksz);
208 if (!di_buffer) {
209 printf("No memory\n");
210 return;
211 }
212 dib_start_addr = di_buffer;
213 blknr = le32_to_cpu(inode->b.blocks.double_indir_block);
214 status = ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0,
215 fs->blksz, (char *)di_buffer);
216 for (i = 0; i < fs->blksz / sizeof(int); i++) {
217 if (*di_buffer == 0)
218 break;
219
220 debug("DICB releasing %u\n", *di_buffer);
221 bg_idx = le32_to_cpu(*di_buffer) / blk_per_grp;
222 if (fs->blksz == 1024) {
223 remainder = le32_to_cpu(*di_buffer) % blk_per_grp;
224 if (!remainder)
225 bg_idx--;
226 }
227 /* get block group descriptor table */
228 bgd = ext4fs_get_group_descriptor(fs, bg_idx);
229 ext4fs_reset_block_bmap(le32_to_cpu(*di_buffer),
230 fs->blk_bmaps[bg_idx], bg_idx);
231 di_buffer++;
232 ext4fs_bg_free_blocks_inc(bgd, fs);
233 ext4fs_sb_free_blocks_inc(fs->sb);
234 /* journal backup */
235 if (prev_bg_bmap_idx != bg_idx) {
236 uint64_t b_bitmap_blk =
237 ext4fs_bg_get_block_id(bgd, fs);
238 status = ext4fs_devread(b_bitmap_blk
239 * fs->sect_perblk, 0,
240 fs->blksz,
241 journal_buffer);
242 if (status == 0)
243 goto fail;
244
245 if (ext4fs_log_journal(journal_buffer,
246 b_bitmap_blk))
247 goto fail;
248 prev_bg_bmap_idx = bg_idx;
249 }
250 }
251
252 /* removing the parent double indirect block */
253 blknr = le32_to_cpu(inode->b.blocks.double_indir_block);
254 bg_idx = blknr / blk_per_grp;
255 if (fs->blksz == 1024) {
256 remainder = blknr % blk_per_grp;
257 if (!remainder)
258 bg_idx--;
259 }
260 /* get block group descriptor table */
261 bgd = ext4fs_get_group_descriptor(fs, bg_idx);
262 ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
263 ext4fs_bg_free_blocks_inc(bgd, fs);
264 ext4fs_sb_free_blocks_inc(fs->sb);
265 /* journal backup */
266 if (prev_bg_bmap_idx != bg_idx) {
267 uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs);
268 status = ext4fs_devread(b_bitmap_blk * fs->sect_perblk,
269 0, fs->blksz, journal_buffer);
270 if (status == 0)
271 goto fail;
272
273 if (ext4fs_log_journal(journal_buffer, b_bitmap_blk))
274 goto fail;
275 prev_bg_bmap_idx = bg_idx;
276 }
277 debug("DIPB releasing %d\n", blknr);
278 }
279 fail:
280 free(dib_start_addr);
281 free(journal_buffer);
282 }
283
delete_triple_indirect_block(struct ext2_inode * inode)284 static void delete_triple_indirect_block(struct ext2_inode *inode)
285 {
286 int i, j;
287 short status;
288 static int prev_bg_bmap_idx = -1;
289 uint32_t blknr;
290 int remainder;
291 int bg_idx;
292 uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group);
293 __le32 *tigp_buffer = NULL;
294 void *tib_start_addr = NULL;
295 __le32 *tip_buffer = NULL;
296 void *tipb_start_addr = NULL;
297 struct ext2_block_group *bgd = NULL;
298 struct ext_filesystem *fs = get_fs();
299 char *journal_buffer = zalloc(fs->blksz);
300 if (!journal_buffer) {
301 printf("No memory\n");
302 return;
303 }
304
305 if (inode->b.blocks.triple_indir_block != 0) {
306 tigp_buffer = zalloc(fs->blksz);
307 if (!tigp_buffer) {
308 printf("No memory\n");
309 return;
310 }
311 tib_start_addr = tigp_buffer;
312 blknr = le32_to_cpu(inode->b.blocks.triple_indir_block);
313 status = ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0,
314 fs->blksz, (char *)tigp_buffer);
315 for (i = 0; i < fs->blksz / sizeof(int); i++) {
316 if (*tigp_buffer == 0)
317 break;
318 debug("tigp buffer releasing %u\n", *tigp_buffer);
319
320 tip_buffer = zalloc(fs->blksz);
321 if (!tip_buffer)
322 goto fail;
323 tipb_start_addr = tip_buffer;
324 status = ext4fs_devread((lbaint_t)le32_to_cpu(*tigp_buffer) *
325 fs->sect_perblk, 0, fs->blksz,
326 (char *)tip_buffer);
327 for (j = 0; j < fs->blksz / sizeof(int); j++) {
328 if (le32_to_cpu(*tip_buffer) == 0)
329 break;
330 bg_idx = le32_to_cpu(*tip_buffer) / blk_per_grp;
331 if (fs->blksz == 1024) {
332 remainder = le32_to_cpu(*tip_buffer) % blk_per_grp;
333 if (!remainder)
334 bg_idx--;
335 }
336
337 ext4fs_reset_block_bmap(le32_to_cpu(*tip_buffer),
338 fs->blk_bmaps[bg_idx],
339 bg_idx);
340
341 tip_buffer++;
342 /* get block group descriptor table */
343 bgd = ext4fs_get_group_descriptor(fs, bg_idx);
344 ext4fs_bg_free_blocks_inc(bgd, fs);
345 ext4fs_sb_free_blocks_inc(fs->sb);
346 /* journal backup */
347 if (prev_bg_bmap_idx != bg_idx) {
348 uint64_t b_bitmap_blk =
349 ext4fs_bg_get_block_id(bgd, fs);
350 status =
351 ext4fs_devread(
352 b_bitmap_blk *
353 fs->sect_perblk, 0,
354 fs->blksz,
355 journal_buffer);
356 if (status == 0)
357 goto fail;
358
359 if (ext4fs_log_journal(journal_buffer,
360 b_bitmap_blk))
361 goto fail;
362 prev_bg_bmap_idx = bg_idx;
363 }
364 }
365 free(tipb_start_addr);
366 tipb_start_addr = NULL;
367
368 /*
369 * removing the grand parent blocks
370 * which is connected to inode
371 */
372 bg_idx = le32_to_cpu(*tigp_buffer) / blk_per_grp;
373 if (fs->blksz == 1024) {
374 remainder = le32_to_cpu(*tigp_buffer) % blk_per_grp;
375 if (!remainder)
376 bg_idx--;
377 }
378 ext4fs_reset_block_bmap(le32_to_cpu(*tigp_buffer),
379 fs->blk_bmaps[bg_idx], bg_idx);
380
381 tigp_buffer++;
382 /* get block group descriptor table */
383 bgd = ext4fs_get_group_descriptor(fs, bg_idx);
384 ext4fs_bg_free_blocks_inc(bgd, fs);
385 ext4fs_sb_free_blocks_inc(fs->sb);
386 /* journal backup */
387 if (prev_bg_bmap_idx != bg_idx) {
388 uint64_t b_bitmap_blk =
389 ext4fs_bg_get_block_id(bgd, fs);
390 memset(journal_buffer, '\0', fs->blksz);
391 status = ext4fs_devread(b_bitmap_blk *
392 fs->sect_perblk, 0,
393 fs->blksz,
394 journal_buffer);
395 if (status == 0)
396 goto fail;
397
398 if (ext4fs_log_journal(journal_buffer,
399 b_bitmap_blk))
400 goto fail;
401 prev_bg_bmap_idx = bg_idx;
402 }
403 }
404
405 /* removing the grand parent triple indirect block */
406 blknr = le32_to_cpu(inode->b.blocks.triple_indir_block);
407 bg_idx = blknr / blk_per_grp;
408 if (fs->blksz == 1024) {
409 remainder = blknr % blk_per_grp;
410 if (!remainder)
411 bg_idx--;
412 }
413 ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
414 /* get block group descriptor table */
415 bgd = ext4fs_get_group_descriptor(fs, bg_idx);
416 ext4fs_bg_free_blocks_inc(bgd, fs);
417 ext4fs_sb_free_blocks_inc(fs->sb);
418 /* journal backup */
419 if (prev_bg_bmap_idx != bg_idx) {
420 uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs);
421 status = ext4fs_devread(b_bitmap_blk * fs->sect_perblk,
422 0, fs->blksz, journal_buffer);
423 if (status == 0)
424 goto fail;
425
426 if (ext4fs_log_journal(journal_buffer, b_bitmap_blk))
427 goto fail;
428 prev_bg_bmap_idx = bg_idx;
429 }
430 debug("tigp buffer itself releasing %d\n", blknr);
431 }
432 fail:
433 free(tib_start_addr);
434 free(tipb_start_addr);
435 free(journal_buffer);
436 }
437
ext4fs_delete_file(int inodeno)438 static int ext4fs_delete_file(int inodeno)
439 {
440 struct ext2_inode inode;
441 short status;
442 int i;
443 int remainder;
444 long int blknr;
445 int bg_idx;
446 int ibmap_idx;
447 char *read_buffer = NULL;
448 char *start_block_address = NULL;
449 uint32_t no_blocks;
450
451 static int prev_bg_bmap_idx = -1;
452 unsigned int inodes_per_block;
453 uint32_t blkno;
454 unsigned int blkoff;
455 uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group);
456 uint32_t inode_per_grp = le32_to_cpu(ext4fs_root->sblock.inodes_per_group);
457 struct ext2_inode *inode_buffer = NULL;
458 struct ext2_block_group *bgd = NULL;
459 struct ext_filesystem *fs = get_fs();
460 char *journal_buffer = zalloc(fs->blksz);
461 if (!journal_buffer)
462 return -ENOMEM;
463 status = ext4fs_read_inode(ext4fs_root, inodeno, &inode);
464 if (status == 0)
465 goto fail;
466
467 /* read the block no allocated to a file */
468 no_blocks = le32_to_cpu(inode.size) / fs->blksz;
469 if (le32_to_cpu(inode.size) % fs->blksz)
470 no_blocks++;
471
472 /*
473 * special case for symlinks whose target are small enough that
474 *it fits in struct ext2_inode.b.symlink: no block had been allocated
475 */
476 if ((le16_to_cpu(inode.mode) & S_IFLNK) &&
477 le32_to_cpu(inode.size) <= sizeof(inode.b.symlink)) {
478 no_blocks = 0;
479 }
480
481 if (le32_to_cpu(inode.flags) & EXT4_EXTENTS_FL) {
482 /* FIXME delete extent index blocks, i.e. eh_depth >= 1 */
483 struct ext4_extent_header *eh =
484 (struct ext4_extent_header *)
485 inode.b.blocks.dir_blocks;
486 debug("del: dep=%d entries=%d\n", eh->eh_depth, eh->eh_entries);
487 } else {
488 delete_single_indirect_block(&inode);
489 delete_double_indirect_block(&inode);
490 delete_triple_indirect_block(&inode);
491 }
492
493 /* release data blocks */
494 for (i = 0; i < no_blocks; i++) {
495 blknr = read_allocated_block(&inode, i, NULL);
496 if (blknr == 0)
497 continue;
498 if (blknr < 0)
499 goto fail;
500 bg_idx = blknr / blk_per_grp;
501 if (fs->blksz == 1024) {
502 remainder = blknr % blk_per_grp;
503 if (!remainder)
504 bg_idx--;
505 }
506 ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx],
507 bg_idx);
508 debug("EXT4 Block releasing %ld: %d\n", blknr, bg_idx);
509
510 /* get block group descriptor table */
511 bgd = ext4fs_get_group_descriptor(fs, bg_idx);
512 ext4fs_bg_free_blocks_inc(bgd, fs);
513 ext4fs_sb_free_blocks_inc(fs->sb);
514 /* journal backup */
515 if (prev_bg_bmap_idx != bg_idx) {
516 uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs);
517 status = ext4fs_devread(b_bitmap_blk * fs->sect_perblk,
518 0, fs->blksz,
519 journal_buffer);
520 if (status == 0)
521 goto fail;
522 if (ext4fs_log_journal(journal_buffer, b_bitmap_blk))
523 goto fail;
524 prev_bg_bmap_idx = bg_idx;
525 }
526 }
527
528 /* release inode */
529 /* from the inode no to blockno */
530 inodes_per_block = fs->blksz / fs->inodesz;
531 ibmap_idx = inodeno / inode_per_grp;
532
533 /* get the block no */
534 inodeno--;
535 /* get block group descriptor table */
536 bgd = ext4fs_get_group_descriptor(fs, ibmap_idx);
537 blkno = ext4fs_bg_get_inode_table_id(bgd, fs) +
538 (inodeno % inode_per_grp) / inodes_per_block;
539
540 /* get the offset of the inode */
541 blkoff = ((inodeno) % inodes_per_block) * fs->inodesz;
542
543 /* read the block no containing the inode */
544 read_buffer = zalloc(fs->blksz);
545 if (!read_buffer)
546 goto fail;
547 start_block_address = read_buffer;
548 status = ext4fs_devread((lbaint_t)blkno * fs->sect_perblk,
549 0, fs->blksz, read_buffer);
550 if (status == 0)
551 goto fail;
552
553 if (ext4fs_log_journal(read_buffer, blkno))
554 goto fail;
555
556 read_buffer = read_buffer + blkoff;
557 inode_buffer = (struct ext2_inode *)read_buffer;
558 memset(inode_buffer, '\0', fs->inodesz);
559
560 /* write the inode to original position in inode table */
561 if (ext4fs_put_metadata(start_block_address, blkno))
562 goto fail;
563
564 /* update the respective inode bitmaps */
565 inodeno++;
566 ext4fs_reset_inode_bmap(inodeno, fs->inode_bmaps[ibmap_idx], ibmap_idx);
567 ext4fs_bg_free_inodes_inc(bgd, fs);
568 ext4fs_sb_free_inodes_inc(fs->sb);
569 /* journal backup */
570 memset(journal_buffer, '\0', fs->blksz);
571 status = ext4fs_devread(ext4fs_bg_get_inode_id(bgd, fs) *
572 fs->sect_perblk, 0, fs->blksz, journal_buffer);
573 if (status == 0)
574 goto fail;
575 if (ext4fs_log_journal(journal_buffer, ext4fs_bg_get_inode_id(bgd, fs)))
576 goto fail;
577
578 ext4fs_update();
579 ext4fs_deinit();
580 ext4fs_reinit_global();
581
582 if (ext4fs_init() != 0) {
583 printf("error in File System init\n");
584 goto fail;
585 }
586
587 free(start_block_address);
588 free(journal_buffer);
589
590 return 0;
591 fail:
592 free(start_block_address);
593 free(journal_buffer);
594
595 return -1;
596 }
597
ext4fs_init(void)598 int ext4fs_init(void)
599 {
600 short status;
601 int i;
602 uint32_t real_free_blocks = 0;
603 struct ext_filesystem *fs = get_fs();
604
605 /* populate fs */
606 fs->blksz = EXT2_BLOCK_SIZE(ext4fs_root);
607 fs->sect_perblk = fs->blksz >> fs->dev_desc->log2blksz;
608
609 /* get the superblock */
610 fs->sb = zalloc(SUPERBLOCK_SIZE);
611 if (!fs->sb)
612 return -ENOMEM;
613 if (!ext4_read_superblock((char *)fs->sb))
614 goto fail;
615
616 /* init journal */
617 if (ext4fs_init_journal())
618 goto fail;
619
620 /* get total no of blockgroups */
621 fs->no_blkgrp = (uint32_t)ext4fs_div_roundup(
622 le32_to_cpu(ext4fs_root->sblock.total_blocks)
623 - le32_to_cpu(ext4fs_root->sblock.first_data_block),
624 le32_to_cpu(ext4fs_root->sblock.blocks_per_group));
625
626 /* get the block group descriptor table */
627 fs->gdtable_blkno = ((EXT2_MIN_BLOCK_SIZE == fs->blksz) + 1);
628 if (ext4fs_get_bgdtable() == -1) {
629 printf("Error in getting the block group descriptor table\n");
630 goto fail;
631 }
632
633 /* load all the available bitmap block of the partition */
634 fs->blk_bmaps = zalloc(fs->no_blkgrp * sizeof(char *));
635 if (!fs->blk_bmaps)
636 goto fail;
637 for (i = 0; i < fs->no_blkgrp; i++) {
638 fs->blk_bmaps[i] = zalloc(fs->blksz);
639 if (!fs->blk_bmaps[i])
640 goto fail;
641 }
642
643 for (i = 0; i < fs->no_blkgrp; i++) {
644 struct ext2_block_group *bgd =
645 ext4fs_get_group_descriptor(fs, i);
646 status = ext4fs_devread(ext4fs_bg_get_block_id(bgd, fs) *
647 fs->sect_perblk, 0,
648 fs->blksz, (char *)fs->blk_bmaps[i]);
649 if (status == 0)
650 goto fail;
651 }
652
653 /* load all the available inode bitmap of the partition */
654 fs->inode_bmaps = zalloc(fs->no_blkgrp * sizeof(unsigned char *));
655 if (!fs->inode_bmaps)
656 goto fail;
657 for (i = 0; i < fs->no_blkgrp; i++) {
658 fs->inode_bmaps[i] = zalloc(fs->blksz);
659 if (!fs->inode_bmaps[i])
660 goto fail;
661 }
662
663 for (i = 0; i < fs->no_blkgrp; i++) {
664 struct ext2_block_group *bgd =
665 ext4fs_get_group_descriptor(fs, i);
666 status = ext4fs_devread(ext4fs_bg_get_inode_id(bgd, fs) *
667 fs->sect_perblk,
668 0, fs->blksz,
669 (char *)fs->inode_bmaps[i]);
670 if (status == 0)
671 goto fail;
672 }
673
674 /*
675 * check filesystem consistency with free blocks of file system
676 * some time we observed that superblock freeblocks does not match
677 * with the blockgroups freeblocks when improper
678 * reboot of a linux kernel
679 */
680 for (i = 0; i < fs->no_blkgrp; i++) {
681 struct ext2_block_group *bgd =
682 ext4fs_get_group_descriptor(fs, i);
683 real_free_blocks = real_free_blocks +
684 ext4fs_bg_get_free_blocks(bgd, fs);
685 }
686 if (real_free_blocks != ext4fs_sb_get_free_blocks(fs->sb))
687 ext4fs_sb_set_free_blocks(fs->sb, real_free_blocks);
688
689 return 0;
690 fail:
691 ext4fs_deinit();
692
693 return -1;
694 }
695
ext4fs_deinit(void)696 void ext4fs_deinit(void)
697 {
698 int i;
699 struct ext2_inode inode_journal;
700 struct journal_superblock_t *jsb;
701 uint32_t blknr;
702 struct ext_filesystem *fs = get_fs();
703 uint32_t new_feature_incompat;
704
705 /* free journal */
706 char *temp_buff = zalloc(fs->blksz);
707 if (temp_buff) {
708 ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO,
709 &inode_journal);
710 blknr = read_allocated_block(&inode_journal,
711 EXT2_JOURNAL_SUPERBLOCK, NULL);
712 ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, fs->blksz,
713 temp_buff);
714 jsb = (struct journal_superblock_t *)temp_buff;
715 jsb->s_start = 0;
716 put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz),
717 (struct journal_superblock_t *)temp_buff, fs->blksz);
718 free(temp_buff);
719 }
720 ext4fs_free_journal();
721
722 /* get the superblock */
723 ext4_read_superblock((char *)fs->sb);
724 new_feature_incompat = le32_to_cpu(fs->sb->feature_incompat);
725 new_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER;
726 fs->sb->feature_incompat = cpu_to_le32(new_feature_incompat);
727 put_ext4((uint64_t)(SUPERBLOCK_SIZE),
728 (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE);
729 free(fs->sb);
730 fs->sb = NULL;
731
732 if (fs->blk_bmaps) {
733 for (i = 0; i < fs->no_blkgrp; i++) {
734 free(fs->blk_bmaps[i]);
735 fs->blk_bmaps[i] = NULL;
736 }
737 free(fs->blk_bmaps);
738 fs->blk_bmaps = NULL;
739 }
740
741 if (fs->inode_bmaps) {
742 for (i = 0; i < fs->no_blkgrp; i++) {
743 free(fs->inode_bmaps[i]);
744 fs->inode_bmaps[i] = NULL;
745 }
746 free(fs->inode_bmaps);
747 fs->inode_bmaps = NULL;
748 }
749
750
751 free(fs->gdtable);
752 fs->gdtable = NULL;
753 /*
754 * reinitiliazed the global inode and
755 * block bitmap first execution check variables
756 */
757 fs->first_pass_ibmap = 0;
758 fs->first_pass_bbmap = 0;
759 fs->curr_inode_no = 0;
760 fs->curr_blkno = 0;
761 }
762
763 /*
764 * Write data to filesystem blocks. Uses same optimization for
765 * contigous sectors as ext4fs_read_file
766 */
ext4fs_write_file(struct ext2_inode * file_inode,int pos,unsigned int len,const char * buf)767 static int ext4fs_write_file(struct ext2_inode *file_inode,
768 int pos, unsigned int len, const char *buf)
769 {
770 int i;
771 int blockcnt;
772 uint32_t filesize = le32_to_cpu(file_inode->size);
773 struct ext_filesystem *fs = get_fs();
774 int log2blksz = fs->dev_desc->log2blksz;
775 int log2_fs_blocksize = LOG2_BLOCK_SIZE(ext4fs_root) - log2blksz;
776 int previous_block_number = -1;
777 int delayed_start = 0;
778 int delayed_extent = 0;
779 int delayed_next = 0;
780 const char *delayed_buf = NULL;
781
782 /* Adjust len so it we can't read past the end of the file. */
783 if (len > filesize)
784 len = filesize;
785
786 blockcnt = ((len + pos) + fs->blksz - 1) / fs->blksz;
787
788 for (i = pos / fs->blksz; i < blockcnt; i++) {
789 long int blknr;
790 int blockend = fs->blksz;
791 int skipfirst = 0;
792 blknr = read_allocated_block(file_inode, i, NULL);
793 if (blknr <= 0)
794 return -1;
795
796 blknr = blknr << log2_fs_blocksize;
797
798 if (blknr) {
799 if (previous_block_number != -1) {
800 if (delayed_next == blknr) {
801 delayed_extent += blockend;
802 delayed_next += blockend >> log2blksz;
803 } else { /* spill */
804 put_ext4((uint64_t)
805 ((uint64_t)delayed_start << log2blksz),
806 delayed_buf,
807 (uint32_t) delayed_extent);
808 previous_block_number = blknr;
809 delayed_start = blknr;
810 delayed_extent = blockend;
811 delayed_buf = buf;
812 delayed_next = blknr +
813 (blockend >> log2blksz);
814 }
815 } else {
816 previous_block_number = blknr;
817 delayed_start = blknr;
818 delayed_extent = blockend;
819 delayed_buf = buf;
820 delayed_next = blknr +
821 (blockend >> log2blksz);
822 }
823 } else {
824 if (previous_block_number != -1) {
825 /* spill */
826 put_ext4((uint64_t) ((uint64_t)delayed_start <<
827 log2blksz),
828 delayed_buf,
829 (uint32_t) delayed_extent);
830 previous_block_number = -1;
831 }
832 }
833 buf += fs->blksz - skipfirst;
834 }
835 if (previous_block_number != -1) {
836 /* spill */
837 put_ext4((uint64_t) ((uint64_t)delayed_start << log2blksz),
838 delayed_buf, (uint32_t) delayed_extent);
839 previous_block_number = -1;
840 }
841
842 return len;
843 }
844
ext4fs_write(const char * fname,const char * buffer,unsigned long sizebytes,int type)845 int ext4fs_write(const char *fname, const char *buffer,
846 unsigned long sizebytes, int type)
847 {
848 int ret = 0;
849 struct ext2_inode *file_inode = NULL;
850 unsigned char *inode_buffer = NULL;
851 int parent_inodeno;
852 int inodeno;
853 time_t timestamp = 0;
854
855 uint64_t bytes_reqd_for_file;
856 unsigned int blks_reqd_for_file;
857 unsigned int blocks_remaining;
858 int existing_file_inodeno;
859 char *temp_ptr = NULL;
860 long int itable_blkno;
861 long int parent_itable_blkno;
862 long int blkoff;
863 struct ext2_sblock *sblock = &(ext4fs_root->sblock);
864 unsigned int inodes_per_block;
865 unsigned int ibmap_idx;
866 struct ext2_block_group *bgd = NULL;
867 struct ext_filesystem *fs = get_fs();
868 ALLOC_CACHE_ALIGN_BUFFER(char, filename, 256);
869 bool store_link_in_inode = false;
870 memset(filename, 0x00, 256);
871
872 if (type != FILETYPE_REG && type != FILETYPE_SYMLINK)
873 return -1;
874
875 g_parent_inode = zalloc(fs->inodesz);
876 if (!g_parent_inode)
877 goto fail;
878
879 if (ext4fs_init() != 0) {
880 printf("error in File System init\n");
881 return -1;
882 }
883
884 if (le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) {
885 printf("Unsupported feature metadata_csum found, not writing.\n");
886 return -1;
887 }
888
889 inodes_per_block = fs->blksz / fs->inodesz;
890 parent_inodeno = ext4fs_get_parent_inode_num(fname, filename, F_FILE);
891 if (parent_inodeno == -1)
892 goto fail;
893 if (ext4fs_iget(parent_inodeno, g_parent_inode))
894 goto fail;
895 /* do not mess up a directory using hash trees */
896 if (le32_to_cpu(g_parent_inode->flags) & EXT4_INDEX_FL) {
897 printf("hash tree directory\n");
898 goto fail;
899 }
900 /* check if the filename is already present in root */
901 existing_file_inodeno = ext4fs_filename_unlink(filename);
902 if (existing_file_inodeno != -1) {
903 ret = ext4fs_delete_file(existing_file_inodeno);
904 fs->first_pass_bbmap = 0;
905 fs->curr_blkno = 0;
906
907 fs->first_pass_ibmap = 0;
908 fs->curr_inode_no = 0;
909 if (ret)
910 goto fail;
911 }
912
913 /* calculate how many blocks required */
914 if (type == FILETYPE_SYMLINK &&
915 sizebytes <= sizeof(file_inode->b.symlink)) {
916 store_link_in_inode = true;
917 bytes_reqd_for_file = 0;
918 } else {
919 bytes_reqd_for_file = sizebytes;
920 }
921
922 blks_reqd_for_file = lldiv(bytes_reqd_for_file, fs->blksz);
923 if (do_div(bytes_reqd_for_file, fs->blksz) != 0) {
924 blks_reqd_for_file++;
925 debug("total bytes for a file %u\n", blks_reqd_for_file);
926 }
927 blocks_remaining = blks_reqd_for_file;
928 /* test for available space in partition */
929 if (le32_to_cpu(fs->sb->free_blocks) < blks_reqd_for_file) {
930 printf("Not enough space on partition !!!\n");
931 goto fail;
932 }
933
934 inodeno = ext4fs_update_parent_dentry(filename, type);
935 if (inodeno == -1)
936 goto fail;
937 /* prepare file inode */
938 inode_buffer = zalloc(fs->inodesz);
939 if (!inode_buffer)
940 goto fail;
941 file_inode = (struct ext2_inode *)inode_buffer;
942 file_inode->size = cpu_to_le32(sizebytes);
943 if (type == FILETYPE_SYMLINK) {
944 file_inode->mode = cpu_to_le16(S_IFLNK | S_IRWXU | S_IRWXG |
945 S_IRWXO);
946 if (store_link_in_inode) {
947 strncpy(file_inode->b.symlink, buffer, sizebytes);
948 sizebytes = 0;
949 }
950 } else {
951 file_inode->mode = cpu_to_le16(S_IFREG | S_IRWXU | S_IRGRP |
952 S_IROTH | S_IXGRP | S_IXOTH);
953 }
954 /* ToDo: Update correct time */
955 file_inode->mtime = cpu_to_le32(timestamp);
956 file_inode->atime = cpu_to_le32(timestamp);
957 file_inode->ctime = cpu_to_le32(timestamp);
958 file_inode->nlinks = cpu_to_le16(1);
959
960 /* Allocate data blocks */
961 ext4fs_allocate_blocks(file_inode, blocks_remaining,
962 &blks_reqd_for_file);
963 file_inode->blockcnt = cpu_to_le32((blks_reqd_for_file * fs->blksz) >>
964 LOG2_SECTOR_SIZE);
965
966 temp_ptr = zalloc(fs->blksz);
967 if (!temp_ptr)
968 goto fail;
969 ibmap_idx = inodeno / le32_to_cpu(ext4fs_root->sblock.inodes_per_group);
970 inodeno--;
971 bgd = ext4fs_get_group_descriptor(fs, ibmap_idx);
972 itable_blkno = ext4fs_bg_get_inode_table_id(bgd, fs) +
973 (inodeno % le32_to_cpu(sblock->inodes_per_group)) /
974 inodes_per_block;
975 blkoff = (inodeno % inodes_per_block) * fs->inodesz;
976 ext4fs_devread((lbaint_t)itable_blkno * fs->sect_perblk, 0, fs->blksz,
977 temp_ptr);
978 if (ext4fs_log_journal(temp_ptr, itable_blkno))
979 goto fail;
980
981 memcpy(temp_ptr + blkoff, inode_buffer, fs->inodesz);
982 if (ext4fs_put_metadata(temp_ptr, itable_blkno))
983 goto fail;
984 /* copy the file content into data blocks */
985 if (ext4fs_write_file(file_inode, 0, sizebytes, buffer) == -1) {
986 printf("Error in copying content\n");
987 /* FIXME: Deallocate data blocks */
988 goto fail;
989 }
990 ibmap_idx = parent_inodeno / le32_to_cpu(ext4fs_root->sblock.inodes_per_group);
991 parent_inodeno--;
992 bgd = ext4fs_get_group_descriptor(fs, ibmap_idx);
993 parent_itable_blkno = ext4fs_bg_get_inode_table_id(bgd, fs) +
994 (parent_inodeno %
995 le32_to_cpu(sblock->inodes_per_group)) / inodes_per_block;
996 blkoff = (parent_inodeno % inodes_per_block) * fs->inodesz;
997 if (parent_itable_blkno != itable_blkno) {
998 memset(temp_ptr, '\0', fs->blksz);
999 ext4fs_devread((lbaint_t)parent_itable_blkno * fs->sect_perblk,
1000 0, fs->blksz, temp_ptr);
1001 if (ext4fs_log_journal(temp_ptr, parent_itable_blkno))
1002 goto fail;
1003
1004 memcpy(temp_ptr + blkoff, g_parent_inode, fs->inodesz);
1005 if (ext4fs_put_metadata(temp_ptr, parent_itable_blkno))
1006 goto fail;
1007 } else {
1008 /*
1009 * If parent and child fall in same inode table block
1010 * both should be kept in 1 buffer
1011 */
1012 memcpy(temp_ptr + blkoff, g_parent_inode, fs->inodesz);
1013 gd_index--;
1014 if (ext4fs_put_metadata(temp_ptr, itable_blkno))
1015 goto fail;
1016 }
1017 ext4fs_update();
1018 ext4fs_deinit();
1019
1020 fs->first_pass_bbmap = 0;
1021 fs->curr_blkno = 0;
1022 fs->first_pass_ibmap = 0;
1023 fs->curr_inode_no = 0;
1024 free(inode_buffer);
1025 free(g_parent_inode);
1026 free(temp_ptr);
1027 g_parent_inode = NULL;
1028
1029 return 0;
1030 fail:
1031 ext4fs_deinit();
1032 free(inode_buffer);
1033 free(g_parent_inode);
1034 free(temp_ptr);
1035 g_parent_inode = NULL;
1036
1037 return -1;
1038 }
1039
ext4_write_file(const char * filename,void * buf,loff_t offset,loff_t len,loff_t * actwrite)1040 int ext4_write_file(const char *filename, void *buf, loff_t offset,
1041 loff_t len, loff_t *actwrite)
1042 {
1043 int ret;
1044
1045 if (offset != 0) {
1046 printf("** Cannot support non-zero offset **\n");
1047 return -1;
1048 }
1049
1050 ret = ext4fs_write(filename, buf, len, FILETYPE_REG);
1051 if (ret) {
1052 printf("** Error ext4fs_write() **\n");
1053 goto fail;
1054 }
1055
1056 *actwrite = len;
1057
1058 return 0;
1059
1060 fail:
1061 *actwrite = 0;
1062
1063 return -1;
1064 }
1065
ext4fs_create_link(const char * target,const char * fname)1066 int ext4fs_create_link(const char *target, const char *fname)
1067 {
1068 return ext4fs_write(fname, target, strlen(target), FILETYPE_SYMLINK);
1069 }
1070