1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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
34static 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
39static 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
44static 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
57static 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
70static 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
78 put_ext4((uint64_t)(SUPERBLOCK_SIZE),
79 (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE);
80
81
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
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
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
109int 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
117 fs->gdtable = zalloc(gdsize_total);
118 if (!fs->gdtable)
119 return -ENOMEM;
120
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;
132fail:
133 free(fs->gdtable);
134 fs->gdtable = NULL;
135
136 return -1;
137}
138
139static 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
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
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
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 }
183fail:
184 free(journal_buffer);
185}
186
187static 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
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
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
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
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
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 }
279fail:
280 free(dib_start_addr);
281 free(journal_buffer);
282}
283
284static 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
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
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
370
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
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
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
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
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
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 }
432fail:
433 free(tib_start_addr);
434 free(tipb_start_addr);
435 free(journal_buffer);
436}
437
438static 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
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
474
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
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
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
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
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
529
530 inodes_per_block = fs->blksz / fs->inodesz;
531 ibmap_idx = inodeno / inode_per_grp;
532
533
534 inodeno--;
535
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
541 blkoff = ((inodeno) % inodes_per_block) * fs->inodesz;
542
543
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
561 if (ext4fs_put_metadata(start_block_address, blkno))
562 goto fail;
563
564
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
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;
591fail:
592 free(start_block_address);
593 free(journal_buffer);
594
595 return -1;
596}
597
598int 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
606 fs->blksz = EXT2_BLOCK_SIZE(ext4fs_root);
607 fs->sect_perblk = fs->blksz >> fs->dev_desc->log2blksz;
608
609
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
617 if (ext4fs_init_journal())
618 goto fail;
619
620
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
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
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
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
676
677
678
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;
690fail:
691 ext4fs_deinit();
692
693 return -1;
694}
695
696void 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
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
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
755
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
765
766
767static 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
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 {
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
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
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
845int 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
896 if (le32_to_cpu(g_parent_inode->flags) & EXT4_INDEX_FL) {
897 printf("hash tree directory\n");
898 goto fail;
899 }
900
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
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
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
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
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
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
985 if (ext4fs_write_file(file_inode, 0, sizebytes, buffer) == -1) {
986 printf("Error in copying content\n");
987
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
1010
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;
1030fail:
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
1040int 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
1060fail:
1061 *actwrite = 0;
1062
1063 return -1;
1064}
1065
1066int ext4fs_create_link(const char *target, const char *fname)
1067{
1068 return ext4fs_write(fname, target, strlen(target), FILETYPE_SYMLINK);
1069}
1070
