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