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